j$;B1;br
z4YvdpbdF4RtGJ&nF{&5z2D_<=
z&gl=_&Y~?b7StjU<7670%jUlmpJR)m@~A36HHME+W}w9eTB&rlDEr43XZ)?{%YSi^
zxSX&QW%sxj1D4FlvdNxjZv&Vp+i=htZ^7lrZd0gNvD^8VXC
z{E;Wy$ijQbk<<%>cuWbV8T)I5u>@F_68JNB!ev)hX0qt!0BZq`_rsU_!;iKrPtlUA
z4}WTmT`Da(l`~77l&Y3V>K|yy?VDp2!&%<;)Ycnj)~S^IUdSr7$FRtoU`rCC?*1`O
zVMc^d(g;A4f|Xso3!N?w5mCezAxxt>=F!@k-(87>O+8H^9@oQdB5!NCrqG_4)l#6e
zFbBJ^(!ua9Q*=eo@RTA^_~ih7sAtSstSY=;*xaiJyJ$Lkm_cr?R!!HLmF
z+J*h;M?a;2WZ_fzD^M_`mKMSSB&>%L*p@iMp*WOZ3`v}Butli}7IxMq)igO2sqq=E
zY!v1*M}VJgM9m(Mt^_A79&RwX2neKov|YKpf9=z4P9Qj_hCW4f`rONQ*#NLIJarU1-@p9%&212s~UQmjp;jV#uPs!EPRMH=zRMw=3Gg^W8HRT-Zah
zJmMChF+zR@_>uOg@l)rg%1^{k11+S5kJCbF5j}))n7~1!*dYsHyh+~^X~C%>#MpA>
z<#Y!Lv?Yux+1!B(3EF5_zw(Cvo-)u62w!HJ4NT5iuyV*rwnf
z?asmnn}T=4Qvgoha%_7A41b``)+{GTIB{V(6j)&z-EG;o%6-@s-J=)Sv`EKB^wM%x
zH5lBSlBayKxz?tmWt*Q_8Jh!dT)aQ6UQUOeq71oWf4c;%8t^iQgbm&uQ
zVNAzziVmxm`2Jr&G$6qi2`>a^(+;V4aPz@gp7dggdJaFrc^`g4C0_^^-H9aEm4~KTC<^zcLhPpV>evnLsdbYw)4YtwoB;8b)~Ox~k>%G|ZpMLlQS=T(-qM0DxZ*J}kFX_>@JX&w#iM
z9c2Q^&O_oag$FIMlE*wW7g64V&1u{!M+XHs?IV6zikaz+GcjHFMnNu1`Kb9LYdDOp
zSiFl&0U9Dgfj?>!ZV^i{StEo4!kYru(#1=*$B!%WS#tu%fJsyGCr1NLj&|PtN+}%d
zIJ_J(lN?0UwIv7GsM%u9qh6~3OBWBCIIV&QaiLDq5+^h7xtZ2r_Q}n-5&SZD)j=R<
zD&80U7yL`Z#!wiO;961A>tIkFXci(xgBVsMlH+3MEkGc);ADsz+F*);M!K_cI1_`;P^Sm#OS3v%a(pi#
zjz%0$fXP1gZ|y8)VvswI;M{4wK>;
zY8%w|EY*qSL8FyWK`^le??R4KK)O)DFwulCl~9jgCB%}~#Q_NI80n72y2DjzP+%lW
z6qpo^!$MjGqN>6cRk5Y5L?$W#!J0WDT;+(YHGC0nxBbpsqu`%v>8`!KLMw>zc41w)
z{v-^tC@1Ed5f=h{ohRn-tF#8TBsw%k&FJ8my|*-b)HDzI%|mgvq`#s}7!oIJ`^k4z
zbjsX!1^?5E-@YrcV>_^}_lBFdSC70vGI;4F;k^~Q~L&cfK
zbXwBiFg_w!7*k-}D@v}Ktq9o?2u?9k=v*vCAgR-G8FQCn5}H9*|6v5b02oAqAnVTz
zgyoJhe3hk|@>v~;`Caft4gjgr(PhxM?;myqsFczNdCg!+YnHWwAh2wazxOkHB;kYT
zZUx3=b#;VZr!%Oibw{bGxm(EaJ(jYd`uDV$Th2t4cpvJ6+eh2PH96bs*(TR%^#*8V
z73a9dTTXNzEWqzBH#IqWFK*&DEYNM>A{aP%#%b|EYB*+-qz~v!wqrJcs4N^BQuhtJ
z2onvGY6x|Orcx)Z0g#L@ryR?owrL1PqJ%8YDALh|YfYeE2iYq4
z8uXz35lD&7!D^TB_j0=LW+3Qz3-LLqTY{yqe}?U>3sY0dzG2|qD*Ba9zl8UQs))MG%K
z1t#u2D70f}IerQCY6;@lnv@EQM|-Zu^;bv3ni6?|Iah-=wkj}4gjQ@$HSmNgp_Xl7
zRDf6-FN9d^@0S%o^F6L}_}Zu*!9$KEdIXPhG<}b2Q}%QWwW(*ukkx>Jhd-Y8_6{fn
ze0PzEBkapVK}Sm?hy?N_C4_V?A$*y3zW2AgdF^Y_A=o_3%13)M4rYby#T4pNDkf(=
zZGfQ5U8io|Y&Mzn2bMo8v&3ts7vFy%O2o$LMXiCj
zVKnq&^(qGvS#3cPjnZ;m;}>WcEsI2{YKj4o?;-nH&R(?@!65AG9mwqW^}Zw(`M;L?
zKT1ICDKPI6zPIyYfDseX6?&^Zig9tZXxj^-wvOpI7R7G}Sv$HJ0d5Z;Nx~c-2?=Ub
zVImad-wC-L<%mSts(@KK1<8UbS*WFCHKBsHm2!T-NV|6D7=)|k3ewS&4LB)IetU}x
z7NrE~-7KyU=oq5oQ;H*e*LgU&WL*=dwCDL(I6~{1-+F#9Rj!lV4I?O*wmN|GuwXN-
zFds;YCJ=VxeVU?nl)~(3)P`)YUzA`=G1gj)Nyp)P873Y=&8f4GT`-54E84?
ztRzYend56D8JF6<4v_6uz|`_2v9jhO#XhHwQqB>`?SI^E$Y+iO8V^qC0i6VVI)*Dg
z2P02I?Le1M=)NOUS`wK!lgs6~zr)bd~cR)ESIS`<)rgZlx^(b5NQ)q#r>EE;(C7>a&ftRS{=-(K<3
z{=(a%@r$L-_WGsxWP8Z`psqO6Y($$yL)i
z=8fh+wF+{FOf2OhVcPxj+7L`izH9@(w1TBt#J)F_;|g99^YTz?TO(Ob?Wl*q@x1Nz
zL7rxVv+)S_+U6jn*D}u@>1ajJynz?iNr`vR8tKLF2NN%Dw*CMU9hch4kx>d%T7`n3
z&$x;#;tZ|w(Ky}4hK#mynsyzZ(!$BIhM$kpHG(IysLBwRT2=idFmkB~@bm6c025_-
z8BW%uvTcXjOSK`PYA>ttHzKaSVcYF2(q@|L!0iwU-d_ysf`pcrBfjer*)j{j(SSn|G<`VU-y!!R1e{JQ$*X6V>#|BB1XxCs-$+=jS@{mRC(8_ho2Vl09w)^-J
zI#K4wj_eyzM31Ul???d<=%a%|YcSQ3Q236Mo?MnZW(+srY8VI9A%yAiVWP`@;E79#
z0q~uu95rm52wMNtp_7jzc}y+q!Bl-Arn=2)4pDqq>1u@a)^d2O!$qL?8h};OWdg_+
z^l=A$^$z-SP^tHNC^TLcBQJ(RdCZ!zVKL_|FlY=_mUy;H3)u;ngm_Sw^I+nUH0V(1
z-^x=Jy_ybniI|Me`kAb!Gmkn2DHcIWKBPk#%)ThDbx*$^VoRsoLB0iu3N8*
zI$|Y&yO8@>EH;HDwE#;LGH(McZQ-%!BeYtg1D~Y>dds76d=i##+SB816eq)c6jM;>
zH>cCsD{>0V-ZlrZKM1%|7Eo(Wm${X>g*au{)AC8&uQ0K5gtAy)$EVQuLI^9jIM>9~
zTFbE~Ou3bqqDK8_M}N5+U(rq}a|S+cGF!^_^`JRoPNpgXDm-aqt2(lkIIG&BB7s4y
zt~5d^yQ`;p+-*GPU*EI%>&N};_bm3hYGgAot0Eodj-eUrg8~6ciRq|xNc-eq(2xef
zPzj_`S&*coAeqootWR=qR{A&TF)MhLkywMMW``Ua#F#xNiy0eJr)ZJp;7ZiA5eG8y
zs(HP-CPOV_nNeV<5(^wdi?s2w%kB14?G{^mjNFm}Rv7N(!0^b1CFeqkTh)2y1f-@%
zqRbB0hsg--?gIg?xs9;fqt1&5Z@wq*U+ckJ{A({4daVqeTC1+T8`lrBsJToN4zQ=S
zL$*2t-#X3?z6ItN3`{P(mR9_YJA;(2q%bMKzi?ZxDzf&;&GP4EV`Xu9W9AmpHCv-;
zX?;{_U7z>Y8sW-0j;pw`C1-2c$lO{&FCwb+HW_<0CSA>R-Z=MA(5jYXyy|l6hIIIH
z>$-IGa%(M5ja9}m3oL!2R@2x&=X0ZknL>|(oWG^-S*+#^y;c&7h2Wl2}|%!2CnwZzoTp+jx2
zr~n@_^bWC4BOG63gh~th?nWspe$hLM@mB9RavKa+whf@HN6(%P9}5sAzIFImfGEAN
zFE*xKL{+f%Y3m+728aLmrXcsYDF|w*ENqobmb;SG%D}4@@x^qByoO?Wz0SE8(`DN0
zDyE}y9*XI(3}7)`rG37lKBYKLF+$D`QTVKAx&tojiTY{ff^%Y-or=XvxD`TJU=c&G
z=k=yOz$ryZOjvy`qH6%7Zc7tsnt0Ks$NSJxosLbUdF@5J|20#Wt;6bA
z_JfmKDx3UDXTl`ZIi$}JIO{_+-Z7z|lt-=91*Rq^yGpy(a*CI+EAkoE%^s>uctKsgreRk|I#+-mC^i762(it!d7M3nsBU>{DzP2=HcyDrh?YPh}Z
za_f4G7OPNvWi1g7^9ie}G!79P;5Gu}3xQ%6><%Rid?^mo87tEz8hcE|IABwZVk9Ys
zv5^$b*6MVL1BkmqYlR*Lt<*ef2LY&Dp;?TGjA6P`u#N*}x>{2m5tgHLiQz+w=V4Pe
zi8rbXl+6HCd9thZb?dC>0vXZ^CtTO}>lD3MRJd#ztLzPZ?KB-bTxSm-KSL|2VW|{U
zs#Hof2@FWZ;FcIkJ8saS`aI-#XSIxN#+e@_TNe_tK-QMSI&=Jdw3pP^0t
z;`?$PqZe+53#P6YPJMLs3L@*(2lH73I$QMp&StSqZjJKGPi`hK64=uqQ36zMRQ|tM
zrj5qF4R5<`(+1H
zGO=~r_8mKSP43>a_vTw}y%hy6%AR2JtWkSPcZkLbKK0Y6JqeG9KC*m#gQZdXhe_H-
zM9uT`9DX2M!Ha+3J(H8!7(zQG{$?=Wfo~`1=W4`f;Y&Ca}
zCh7H5Gdc3rZqL^6;)1XCaF%j6m!#KG&3MjN+n=>~ah`RhrtnbK=5E$EdMLY&yK@Q>
zYtQLWeP6bc2agC+#En>l^FI-{?X?|AI?|c<^;A2fORW0Pxq)r4^f2~!uB;XhOMN|aAaDw`q-drM
zXLP$fbQ30}QM*qT8(TP%#oXQNC2cbs+Kt+~y`*iLCb?c(m8S4-L**(5Ix`D!<1ySaPE
z)sl8F+rx`Hyriwq_HuX7H(HE@_AB
z8_85})Urj|tz@awsO{4llCQ4oIDmcHsG8m&pOIj%MVjO~;`zu+9Hk%^YMg>CkyL9Q
zi95nh)R3-jQ&$cQJQ#f`gAnTB`aXf9B~dA$KJ{+Vr>GjWn`M0)wY^Cu<*>)y?M_J6
zXw)X%-7Z(`bj1!=Y1NXWlyOld!*&+q*nRuS5S18uFVzn#y6sjJQVWVQq6)Rn_!WDcs
zOz-&8n+m=_rh@N;so*_@Jp&UW(a0QhU
zy_hQ)V(45H`=}iSv(059T?AgeE{W;DR#W(DZsqGdBHh+(S&=(~g>Jp3y~sVHo)^RR
zBKL?oFKqQ*phsJRq+^HbtkZo^d_a!%Ksv0bcx>+58$gT)y+3%jEh%iJ&g|ujFVdYh
zklqjhS|UkvzTy0B+WdRulqh`P;;Saw6o992`q?rC6xdg}wKOLZLWHuaz;`Ejkojm*xH28h
zE~YwufCD#1+>(_1gryp0iEaUzqDp5vl6a1vJB+o{7prFV
z_{M-Sn;y_uF!X{37|t-cy$a0a!bMY0?dHODQ{TGvap^02o1YUME!6qA1YL{z^2=nJu3|9e*
zq!B*Yu+nDF^`SB8L(7JH%iNHNy&ab>>vHKJ!LF9ujJ3Ff-$}fRMRQ%rA~Xlkv#8GL
zE#OkICyo~xkj&4q=Rx^l2#{w_w%}TJu-OGWirjP=^v%HJxHE@pA$NM1+DoVgn)y;7L-#5Vp
zlkZ{8g_B>vnoE0Flj{Yn`6g#9AG(HSmh(-d9uBGAJ=T`iwXIlQRMOg}z*0P%8}2q{
zJ9{(mPlW1r@49tS_)BR4Q4bfFW`3*_%;d9hGb*!CuZkJ*x^Dhx6VjWj`A0HH)=1
z)m7)sf)0sfOBqX-x9ceSCb=Baze`g-jJ}i}DL92P2!IX_rUksNXSl~Isi0CNUETpC
zv83ri6u>eweg;F4hlA-V`iJ?kINCTGl$^0CWn$}4qpW7PFO|>4W5?l)C5?|Gx~6=p
z#6TWYm(J4KUl*y+ZLwua1LG~bB^M>3Pvklu35%+DWT|I{V93@@xb6O>EL91VBsPx1
zzDxZ$@=I38$6u1BiVH7sKK_z)wS4>~>9~CSCFx4}_)8QCCO(+*xfc2Oq;Av8nUt)1
zzW1;Fd2QHHdNbVlP+ln7OOsEle<8CyS
zZT5*BZPwvoP))WCX<>tDp}7_Zly!s_5q92H2kHqP+nZ`DNC!!zu_cClRn{QP8;@N)
z=gfY)#MTrm58*?3Aw$`vSi9+@R1c>ET8{um$<`%o)#ST2pV_Rljh`z;2^k`Afa{pz
zX`$Ehipb93MZk@Gr-Dnh;eaDCWQkjG!>%f`OcK=0=rH?XU
z?GTIt@?+lz!6_?p_gTb)Gb_kLv`=}7fgvo;l(3MI<9M<~LXsm*_DLmy!4Jy7v}|*I
zn*yql`Di^*AlD(i!qWxV#9orX1NZ}%#mtxa>s;l_ttGB!qVB2z9evM$(BO#=tMuYb
z2bDX-)*gt~MrH*1aSL1W!lBa$+r?X#~9B
zWRYpJQUbO4Qb-l@+$CKp_ubAukuRc<0Et!7A*4@AYp}qQ)+p#G)F=h#wE2|2PF1Bz
z@={^p=S!4CDMCSv2=b9x1oRx=2Z4}IUoBvFDS%NZv`XaCgp072$Qj#>%f1+JoJpZ%
zo?@?zNLx6h`we@V=Xn+jn>hjLY%?uvU4z$=U>M5+r*}=sAD`I
zyBt89ney|si)ItFgIDc>o1mL*Z0RNaW9frR>xgUG)&VCF{VgU@Tt#zEM4KL1*vw5(
zUtctRwD7f?pw6%@@){pf6SSptgm^e9kNYM_9h;ysRxt=pCdCPe7S>OnfRmJ>16)#G
z{
zj>29sM;YwqC3q2S+K(G~4aRXM@co+A*K`Q8_lt6zqkoPt*UvRL&Q;A3=Bh5raYX3E
zac1AeaXmbiPpyyRsP8$>PAFf6uq65AcSfr&7W)#Ob@18iS4(tmSfaC%oR{(A5}lWw
zYmLYIBA6d=czn%7XHITt?L{mC120WmZEmm!EK{zT=!{p^o9K)m!z|baT9D|>K@>}L
z=JskvZ_Q6XH9;Jd^VTpT;MuSbk-?VJ}XC}
za}6kHMxrx+3N=r3=Fga7EG^NQOUrWBBSDLI^D>0OgS9N@l?rz1U7qFK@LA6M1=yM9
zM%>s2rpI59_qFe|
z4c4JrI)E3a4Tgw_DA7?KL0XHGTL0b7LpL@V&dk{U#4FoL+Ig@nX00ELoB1kLSARD2
zr2-?Ia@TvbDcO*Ig{8HEC8u_gWV~*e>yH}zeAs567H%d
zWp1gQVm?(D8v+Q}P%tMK6LR2%JqHZIcUJ2RrMw@CcdHM+@c|W7fG|x-Ckw=b9R0lp
z3h`LQlPr!n)M^R%={VaCh%kxKRhJlDwZv#1jq8lCON{1jl!%-iw=;!?26b8mJLnXi
zy>*GvTsn8u>Ar=D(Hzr3oAoC~^Wl3-j9!(wjA-_0zy-=zfh~C>S|3VpS4jjx%IsXX
z?wtRSQ&|+Y?;Y^>w7@;`0YY-Z<_RfAF|SWB0-m7NJQ1b;H8R>mP9@vPC6Y3K(ynrH
zvS1R=Q=MHa2!f6QHAX|QkdyB|6d3($&rCUZbVYeorDaHiN=3>+yFO0R$&gk8d;X71
zP~u%KN7@c>dW*y#AL-;s=afx|>i{R-H)Haud6T;4l#z0zHABNK
zaSqEZv}uD;=rJHPm&CnXITY_Uo$OKVg~Fp)J>BA8FQT&fY-2j0Uj3G+WiIA8cGxa!
z3_#@&k}?gcPu8J^7bZ9^%a$?A01%Pqkbyg0YWi;AF8-bJL41@bY533OMS`QuNgise
z5K0@F?T>6bv#iX>Nu?M#E+B2u?=4t{Wu6+n!ln4wSL7PmPeRHvy*WN@T1VLxf(c99
zcjg+|U)tFs_ePR9+UA4lQ4a%*mZcB*z6p0OQ6*dk<#&P^2Pd6;BhslT
z>xGh}PQ!(fz0qnST0@qooh~Ow(y^A&5;BaYHF!`)(WLD-AKaq4SvIH+2;ymWwoFVs
zHi^``vwqs#b(X;dR-`Az*?3GFFUH-N=9xCfgwXa#3{+aGWKGKs*GWM@Sk(`L6EyP<
z2x`*JoDr3Mn6_JIP$*+xszJc9dDH*GLLdl(xT?%n3`0oj{6ws7m|7>&W_CJ}Jq(N-
zNsH8n+058=rliDhb>J1>HKx^%NE=(yqPR*9>4GUZt+L1z;C&|}f^HG8d+;x?krDH5
z7Jv;U)c%@KTgtWw=FGCc!je?GDcj4%VU~z3iGJzz_
z%E3i)<=GZ3Zm;bvpUB;l#tn9q$W0Jies+*r2pJ9LbdkQc;v`ARoq83iBGUz2xxeJ)
zy`etyU36MkaUW;Cz1H_^+LrJLOj^39hV!qNpriu7=uhT>ve3masE^8j6
z?q
zWO%SaLQ*%L0SD|YT-H|9G8@2a>X=2aE?40y{B=1>erIWLj1k|LOqhy80
zHQYJqlyp8R(5R5MmZ=yAB#P12Diyviy`q?uOD>vhYLuYenp;@hOs
zASPkTi5yFizfRfb_)H*|ElTfUbtTM>O63j|+G?#+xD@xAhv0+>h1>taOgUWb>?CH?
z&PAFxL~@JO4O8nxn#+m6sMlOnHihf0g*HapOH<@bf5tXYGLPj7xa4>xD=alvv1_1m
z9mz<&HY#Q$JCB}@nvGhdf0rF)%;!6HHp4}=`}KD3g!$wn-k{gp{VzDk;>?ZH+Y4sj
z1CwSiZ$2HylXRX7URlrV**>ha;CIx|Ql+|yn%qH8rMfMkXE)2uQZH!ekkq3*%>{M3
zGAC@o(L{vnCv4|M$4ATE;HwE+be+h-@`TlL5mN+VEz8ZPgSai^bm>)DZe57!!dOu{
z9vln7IZj5*$$BRziQP!=N
zwJ0K4OS=R3K1?6VasdNCTK2^`cn#g|Ckmgf&FyLmdKen~V?46@ZGfM)z3JX5_?%oVZb5Wcacm7>Xs-HWXUGC)a
z?{ALE=^9d28)=Yy&<;&iCb>^ICDc!A$v1rn)
zUG7V6BfjR6+Y~aBUrokYp4>*;lrPbAliSE|(!xSXUu5d}Hw!u>AfVItQibi62orx8
z*|@ryu2j<7kcuINzj8Rl?|E{Y&P=P43Mviw8#S$QFEd-)A6C%_q0%3ndk2RR<(t15Brg
z?Ld9FM
zE#T8Msb6U<(Q3Js-*i^gmiDH6H#-2mM8~0(@5VuwG}Yg9snhY9bSbeteF`#P_4MSs
z0Sq35+m<5X-K~1SDt_6?HlOuWN{*~VrIYWrOx}j_-D+Arh(p~6;*{6Gp-i^f`AbfG
zgtXd{Z%3e~s=xRQPw+|8cm79`G1
zb*{?)|NCkTq)Fr8=C>c%GND7Bn}SehKvNEZt{GponscDVhR%UmALrm_Qu`>kI_qg(k*|0!
zhd`6s59AdeL;k>U4
z*;;O&5ZsLw3v>M&koQLW+XE*YU)3a9%xwE#b7u|KL
zae%fD+j}@smFV>BLS*mZRB57vv^MS(=SCBqo?VFQ-5eoJbdc7n9nF?<$LU!#{vGux
zj)x{XJ==%SNsfsoIz?+OKExs6L`P_Q&^alv>49UkoMTONa`vjJZK!QjDAIHhoK&LP
zsRdKJofD*qj?XTf+U*&uRvn);2;P}(;Ev<73#WD@+sF$J(OR`b*(UBdIcrn<5GO7Z
zot*8P+J`tzm+086wRlIijl1JLQ#(|Dht5UP!{PdYYzuE65X|^7FbZ?Q;J_$GHK%tw
z)N|o=9Uj%5iRzgWMxQF5sm7Ym3~iU&CU8uX+EMuiM6^aZJeuf~tx4t%4v!`}T5E#2
zBiqg$M{B#-+`$7*)%G#U{T%*GbgFhCHt)}N@qz=kHtFrzBzK&uU5L&1a1J!l0b8rK
zjl-XbovM`&wT;7{iB8q_3FN&TJWO=Fwhzbmaz-(!y~p>nmGhm6&d7Gy=TLoXZJSBs
z;reEd_9Z$cdlimb9BAyB@NWoN9GCSomOxHs|Dzrv*nPv_mHkh8%$Zr6#|}RJ!0lZ<
z032pIU(~}p7a4aIo^_%_v*na8?vW~`^b9uaB+F5d~x3E5jo#9=up180=YY910mvWxB@YQkY#Q@{tbL`^tbn@J_z?(X&{
z95GKgIBW0rx#Bigyv-H2x`N}ZYHr6_6CG#OogHUQY8+>k{MvEW1fjNfcAPcge7xP+
zan=Ninc}qLtO92aaJLX@_v#|U(wRbs_~
zRuvp*tx|BHRmECYaG+IpZCA8(;4_f`=^+PNRdAqH1qWJHaG+HM2U^u9NrSrMK&uK4
zw5s4hs|pUZUQfY+)*1x|S~YtPw5s4hs|pUZ4pVTTRfd8CttvRss)7TpDmc*Eq9AQl
zdYuEUD(paOq64j)xw8YUiFPM%;m!`UCfXy=9S2%(rik1fYk6bFfB>id;X(O>0#*EX
z7d&ZK*`I|oys}p#Z)EibBH6h1pCgMaofc
zk%nyxWQzA_BcfH3)4`o>vZKFjlZ7;1rF38~EulB06El!LV8(`!y3DkqRlf17%wZIbhm_RU&X%vzn%VvFf5%`K!p_%#Nq5r5hy4`;+fm_!I8_WT
z9P9`uN0=Ps%54dghn{UzDzHBN(zd_ZQDF1A%`!v}*b-AJpl#;*m+VB;-JkC$=*#`1
zs81qguW=M{X$Enm6L*>0)ZnxGIo%Xs0LtpA1W1?zLIp?4}R
zZ#JKl)#WUoIzgLL$tI=XJbS^c{rK#(I}h^~rgsgrzUkQzIA44=L`+=T?_%KVKvNI+
z1mLM`J1cL2I<_S&@^MUtIHkWr%-j`!_CZO8q#L`xoyRf|Zq<&k{v1SS6F8Q+6tBCg
z*hBpZAFLyP!biJU{0Sc&;y}H_wJy^;`R%JtXK33HZTLDTGo0?qbB17cR>1j(@N_E1
zQdC*CyRd)7DK|EE@~ki|h&To0I0{|omo)?8EdKbCn1WBI`_OLxsf*5QR@zcx_;}j0
z$YY`$L-6cI!io;T6C$wmFWXBNZnN$&1E<3{M}iKsvH7bc8r$}CNwCiKR@{4N!{$zA
zyvvtzGxdArD1Rv!VIx1MAw3S1SIu2&NO9}_0~wvk>90Mz*Iu^zQA2*SdR6d=NlLA*
zLpdo6zoWD@ca*lxo$5|~XWi2lIxE8Pi_9I)V*5Uyd-YA7=kR~(Gr3f;qdw`?M*}*C
z0@xX6grKdtJHBywW(B7qy`IcZ?s)uh7{KSQ+OYsx7HjRX=s7OuqpJ9bxQpYXysE=!
zUe)8ZziKJv>)JXBVtCCPI-F|Ep498M_$%XpAqJqL#6tXyhzvo5mq*%(Qy@OuY(4n_;Or=MB4ZX3@
zYg@K7w~ak7W8EqEG*~~iMX`-*=Oo)#>c=(%2*s9k@dhaF!5%0sq8UJ`%iec*2TF%j
zaO?G*u&ll2K0J1s^h6p3=Hgr(z^SqK
z=KOdLch;iIsXe$epd9Y35|Y3M$>$fN7^?ceUB-{#SE0o%06sx8MJo<4T+?1j0!%c)bR&K}$H==3q`
z`-L#6&(rTJepZx%pb=y*(W=I+ehU25`DySo$dAAn3bI!?%XZ(~ERY_Uojp4nWPd_8
zOL(XH`dJ!ee;FntP2d>fc7k##XE5qC+40=&ptXm`{1dwk1=qR
zEM?9Pz}czCj^sdoAxcJuX`Vwg!u2wKmIv9Z{DHFv&(5Bnnwy)RO{X0+^Kr6*j?T{=
z-*Wzm^IIO9I)8f0>|;#(q|Ny!_A-rKV_#@L0Vvj6Pkw`6CY;O@(XWW`Dkqu?ClXPh6=
z3Lf}IA=z|=aW#zq*o{7v{EuP{0)Xt46Lz1yP)tJD@x@|Ne2JFZ0ic*{KXZ0&dT)B~
zg)`}6C*~ebkKTL#eeXH4KfC?T_uQM^e&E)vM-2m0=>t>8PR`9v9h(;9SBgo+PxVG7
zUP=aU?9O>=F6H5+QWD>|F%7a8N(q0mIeUqMmY=0q!(2#-kY
z-=aBve!G;^h5wu<+6;sLd~E6r(@AHik6oBOf8x>UQ%|H*$Ie|iF*}`}zA!iaIOCR+
z`YWJA9FXz@KfY2ZPITC3^$r}&XTRg%@+?vEThd;0X*Gh4dYl#IVZvr8f}|EVMx{3?$g;Zg$h
zO8{I1>6K)No{pWJo!&A#eg49!IfL+0HHr3ulTTKYk?W|fe)O}JpX>R#0T`;uu!q4R
zeaq>y$F1?J)i;B+`2m0__F?UXfn@T*DVY0sI(IfjnN815%}s-n6Xz~Wr=GNj-o7_|
z;KbZ{gnc@le*EF73+Lyij|bTw(ceqJD6ziGM+L^qC!#k}_VOX?m)`EB6+
zB}!rZFyb=;57(0B)G0~y6De{#d-gFw|3WR<<2h~0I!dR~_uO?~`smatrhfc_G-Ha^
zn0ioJ>BL-m;(U61`uyDN*(cQe)mpOQ7-|mCj~;$R6WY7?!kNcrryg0i{-|a%l^%W9
z*)!8eU57wX@6!FOH89e>R8K~8;NVxduouWL*OR*bYA};AU4Y>KQ9Wt)KCh=Ar3y>ePvc&YXtH1yE8Ex9-|Hxpnu}J=-R>ZQZtQ
z+xBfcw(Z=uYun_u-P`tTpV+>2`?l@dx9`}#bNjCCliPQ1-?L+4$JQO&c5L6VW5>=N
zyLL?O*u7)V&WW8{cW&FcedmsyJ9qBdIk|K9&ON&(c5U6YZP)f)J9h2dwQJYpuHC!#
zOioO0o!mCLeR9X-&dFVqlasqA_w1h7y><7t-P?EX*u8W2uHBQnckkY_2N3r#{2sdA
zL$f_Rf_axFg_QqLg~Lg>5t31$>|UVY;Y$?j&^;9EG3dj|$VO0@^X4Y5H}kUv))-ET
z-@AG9=I^6RYF$CSCA@hRBP@$|4<&T`=tyz`{B%s{=}K%(~pbOS0*<|vq>3GrKpZsROE#-$ERkWxY;Yc6KBq!I6f@_SeaDPb!vW|
zyO&ocrS<9A2h*cizLiNx@#@OAsuRZ+*NJ0Eu;C2bW9wj#A?9eRMpjr(DW*EeEGC
z(F@~dUd=G8k=`p2e`HD*ze^uh4>YMpq
zjQ6w}3MY)eI$2^+>Zu#mp1-g8I{LZj
z=L`R=@}Hvrr}&=>--%yC=e)2cc`3U5_!B?;@&A6}eeXZ|(I5WUrSVmN+8Dg^uFYF+
z`{4H-`Q`uZxsU(IC;pqC`=wv|mtXwSSAOfyzWx`5p(X3L?wH(r^R0*8`F+p*2(Lc#
zYya{~zxCCxef=+jLcL*c_uhQq;GuVZ==k(=pZJNN`pQ?oR;UlHKXB-M+<*KNKS%X1
ze&x@<{uftxdf?FU>G@}#`yW2{>!1IFKfLlcAO8N2{NN9N?D-d7{Mk?c+%NpvuYdlF
zzxma#{qetj$MgT{Uw`SVUpw@!!|(f^4;}fzANkQ=`jub({BL~eH~(;G+4ArG;D7j!
z-+67me)`;>{dr?>&6%^~tBySN^gsW_|FmrR>NN-Nc-P_gf8c{3divrofARPK;7_jn
z&Hpuf{zvC7{G%WH%9bNHY~J#zU;Ne2|K`{J@XvpI-;X`NW#UKIy!MOVdF`vOz3cD?
zzPDT%Y~Hx#um1YX*~wdP+kfEFC%*IAeGgsu@>gE@-9P$Y{*Ujx7G%HMO1>DSN7~Q+
zdEwc&SH_CPp=W-fadYwH&ehB2|2$q%2@CCbps=G*=F=mkax=MSa7p?8N>mshsK%AJ
z97l0XjHehUrLZwl+#3&-OT}j8z2&GpQopBgd%P(Q3qz&B+TOyd>+7Yv($j^R>*v2*
zeDu
zTAly-U30bhf3vbyoPVu2|0~6{wV(LX!0&AsdG6!!Wc8U34$ptKGXL4zb`}OoyDJAP
zwbER&I{rZ6d#dvv9vvT8Ry{Z{|3jsJ_F`>$Ve8Knp84Y&%C%x~{+|v#bGrHXx|>RO
z73M!)nE&;7EFMJke}=uoQW!Gh2)>R6;v{N@Lxm;9rAvmRk!WQ+UR+gJ8_vWhqt8XZ
z8~uLm532tr`orjt!&i&ni2f?QQuv$j|Hgh_S)2T$uy*6kZ+q9_AN}c{{>P$dOS`;K?sbrI%mXavPq@4aqm6
z54HbcF@_w|g>cK}`Da(fTL;GrYpbh^8;Wl)G;W&z`O@0L+QPcZjwGDF^vq;+*+6Cf
z`91NmN_Apcu@#RM!+pC8cNW(b;zG4jE$>TjEYzyI;=RR{Qpn#%EzbY&huZI`49x%RhuQ~{fl__x
z?#jTfl`)FsnWOjB!e@eaRPI}~=b7@sfmQJxhbH4jW#HML{qT=Jcp;hp!Vi7!xh+5X
zyU*V7Gyme*J>{DU(a{?Q4i2m2SUuf2Dm9)GZK>z-BhjfESZ3yR@#d`rcaM
z)_8n)bX_>O{3C=OzO^nHxr8Z^|M4iln9}ZhDIVzIxN50Dki(paBwmO!FkS
zQf}ji0L7&ZNwj%0YugP;{R)8Uze|)XkYC)89FWz~f2sXm%*A;#{$+M$Lz3*b<(*#=
z&TmW_?!ny`=KQlu8MW=s-$BV?np4*g+
zJmNcefwCup_QIxXEUP}VDG5s~f@%5+O+;S8WWD5lWz$=v+5F~3f&S!XJV&~2Gr}GW
zKk>#Fdmim|k3O>*?xvRFRxeS?XZi}rLzn&zwU6@XIv#z3+N*F#HYe9z6|n4as?M|C
zcM*>*$@tWHBB>S)a8Zc8>FE>4<>ukJ;BaoamPhu=mZbf9gXDpcZ*J+r_bFf`g7w@)
L_t8J+(Zv4?U`;jz
literal 0
HcmV?d00001
diff --git a/packages/uni-stacktracey/lib/source-map/lib/read-wasm.js b/packages/uni-stacktracey/lib/source-map/lib/read-wasm.js
new file mode 100644
index 000000000..801989825
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/read-wasm.js
@@ -0,0 +1,51 @@
+/* Determine browser vs node environment by testing the default top level context. Solution courtesy of: https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser */
+if (__PLATFORM_WEB__) {
+ // Web version of reading a wasm file into an array buffer.
+
+ let mappingsWasm = null
+
+ module.exports = function readWasm() {
+ if (typeof mappingsWasm === 'string') {
+ return fetch(mappingsWasm).then((response) => response.arrayBuffer())
+ }
+ if (mappingsWasm instanceof ArrayBuffer) {
+ return Promise.resolve(mappingsWasm)
+ }
+ throw new Error(
+ 'You must provide the string URL or ArrayBuffer contents ' +
+ 'of lib/mappings.wasm by calling ' +
+ "SourceMapConsumer.initialize({ 'lib/mappings.wasm': ... }) " +
+ 'before using SourceMapConsumer'
+ )
+ }
+
+ module.exports.initialize = (input) => (mappingsWasm = input)
+} else {
+ // Node version of reading a wasm file into an array buffer.
+ const fs = require('fs')
+ const path = require('path')
+
+ module.exports = function readWasm() {
+ return new Promise((resolve, reject) => {
+ const wasmPath = path.join(
+ __dirname,
+ '../lib/source-map/lib',
+ 'mappings.wasm'
+ )
+ fs.readFile(wasmPath, null, (error, data) => {
+ if (error) {
+ reject(error)
+ return
+ }
+
+ resolve(data.buffer)
+ })
+ })
+ }
+
+ module.exports.initialize = (_) => {
+ console.debug(
+ 'SourceMapConsumer.initialize is a no-op when running in node.js'
+ )
+ }
+}
diff --git a/packages/uni-stacktracey/lib/source-map/lib/source-map-consumer.js b/packages/uni-stacktracey/lib/source-map/lib/source-map-consumer.js
new file mode 100644
index 000000000..d86b2a926
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/source-map-consumer.js
@@ -0,0 +1,1302 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+const util = require('./util')
+const binarySearch = require('./binary-search')
+const ArraySet = require('./array-set').ArraySet
+const base64VLQ = require('./base64-vlq') // eslint-disable-line no-unused-vars
+const readWasm = require('./read-wasm')
+const wasm = require('./wasm')
+
+const INTERNAL = Symbol('smcInternal')
+
+class SourceMapConsumer {
+ constructor(aSourceMap, aSourceMapURL) {
+ // If the constructor was called by super(), just return Promise.
+ // Yes, this is a hack to retain the pre-existing API of the base-class
+ // constructor also being an async factory function.
+ if (aSourceMap == INTERNAL) {
+ return Promise.resolve(this)
+ }
+
+ return _factory(aSourceMap, aSourceMapURL)
+ }
+
+ static initialize(opts) {
+ readWasm.initialize(opts['lib/mappings.wasm'])
+ }
+
+ static fromSourceMap(aSourceMap, aSourceMapURL) {
+ return _factoryBSM(aSourceMap, aSourceMapURL)
+ }
+
+ /**
+ * Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
+ * (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
+ * function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
+ * for `f` to complete, call `destroy` on the consumer, and return `f`'s return
+ * value.
+ *
+ * You must not use the consumer after `f` completes!
+ *
+ * By using `with`, you do not have to remember to manually call `destroy` on
+ * the consumer, since it will be called automatically once `f` completes.
+ *
+ * ```js
+ * const xSquared = await SourceMapConsumer.with(
+ * myRawSourceMap,
+ * null,
+ * async function (consumer) {
+ * // Use `consumer` inside here and don't worry about remembering
+ * // to call `destroy`.
+ *
+ * const x = await whatever(consumer);
+ * return x * x;
+ * }
+ * );
+ *
+ * // You may not use that `consumer` anymore out here; it has
+ * // been destroyed. But you can use `xSquared`.
+ * console.log(xSquared);
+ * ```
+ */
+ static async with(rawSourceMap, sourceMapUrl, f) {
+ const consumer = await new SourceMapConsumer(rawSourceMap, sourceMapUrl)
+ try {
+ return await f(consumer)
+ } finally {
+ consumer.destroy()
+ }
+ }
+
+ /**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+ _parseMappings(aStr, aSourceRoot) {
+ throw new Error('Subclasses must implement _parseMappings')
+ }
+
+ /**
+ * Iterate over each mapping between an original source/line/column and a
+ * generated line/column in this source map.
+ *
+ * @param Function aCallback
+ * The function that is called with each mapping.
+ * @param Object aContext
+ * Optional. If specified, this object will be the value of `this` every
+ * time that `aCallback` is called.
+ * @param aOrder
+ * Either `SourceMapConsumer.GENERATED_ORDER` or
+ * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+ * iterate over the mappings sorted by the generated file's line/column
+ * order or the original's source/line/column order, respectively. Defaults to
+ * `SourceMapConsumer.GENERATED_ORDER`.
+ */
+ eachMapping(aCallback, aContext, aOrder) {
+ throw new Error('Subclasses must implement eachMapping')
+ }
+
+ /**
+ * Returns all generated line and column information for the original source,
+ * line, and column provided. If no column is provided, returns all mappings
+ * corresponding to a either the line we are searching for or the next
+ * closest line that has any mappings. Otherwise, returns all mappings
+ * corresponding to the given line and either the column we are searching for
+ * or the next closest column that has any offsets.
+ *
+ * The only argument is an object with the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source. The line number is 1-based.
+ * - column: Optional. the column number in the original source.
+ * The column number is 0-based.
+ *
+ * and an array of objects is returned, each with the following properties:
+ *
+ * - line: The line number in the generated source, or null. The
+ * line number is 1-based.
+ * - column: The column number in the generated source, or null.
+ * The column number is 0-based.
+ */
+ allGeneratedPositionsFor(aArgs) {
+ throw new Error('Subclasses must implement allGeneratedPositionsFor')
+ }
+
+ destroy() {
+ throw new Error('Subclasses must implement destroy')
+ }
+}
+
+/**
+ * The version of the source mapping spec that we are consuming.
+ */
+SourceMapConsumer.prototype._version = 3
+SourceMapConsumer.GENERATED_ORDER = 1
+SourceMapConsumer.ORIGINAL_ORDER = 2
+
+SourceMapConsumer.GREATEST_LOWER_BOUND = 1
+SourceMapConsumer.LEAST_UPPER_BOUND = 2
+
+exports.SourceMapConsumer = SourceMapConsumer
+
+/**
+ * A BasicSourceMapConsumer instance represents a parsed source map which we can
+ * query for information about the original file positions by giving it a file
+ * position in the generated source.
+ *
+ * The first parameter is the raw source map (either as a JSON string, or
+ * already parsed to an object). According to the spec, source maps have the
+ * following attributes:
+ *
+ * - version: Which version of the source map spec this map is following.
+ * - sources: An array of URLs to the original source files.
+ * - names: An array of identifiers which can be referenced by individual mappings.
+ * - sourceRoot: Optional. The URL root from which all sources are relative.
+ * - sourcesContent: Optional. An array of contents of the original source files.
+ * - mappings: A string of base64 VLQs which contain the actual mappings.
+ * - file: Optional. The generated file this source map is associated with.
+ *
+ * Here is an example source map, taken from the source map spec[0]:
+ *
+ * {
+ * version : 3,
+ * file: "out.js",
+ * sourceRoot : "",
+ * sources: ["foo.js", "bar.js"],
+ * names: ["src", "maps", "are", "fun"],
+ * mappings: "AA,AB;;ABCDE;"
+ * }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found. This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit?pli=1#
+ */
+class BasicSourceMapConsumer extends SourceMapConsumer {
+ constructor(aSourceMap, aSourceMapURL) {
+ return super(INTERNAL).then((that) => {
+ let sourceMap = aSourceMap
+ if (typeof aSourceMap === 'string') {
+ sourceMap = util.parseSourceMapInput(aSourceMap)
+ }
+
+ const version = util.getArg(sourceMap, 'version')
+ let sources = util.getArg(sourceMap, 'sources')
+ // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
+ // requires the array) to play nice here.
+ const names = util.getArg(sourceMap, 'names', [])
+ let sourceRoot = util.getArg(sourceMap, 'sourceRoot', null)
+ const sourcesContent = util.getArg(sourceMap, 'sourcesContent', null)
+ const mappings = util.getArg(sourceMap, 'mappings')
+ const file = util.getArg(sourceMap, 'file', null)
+
+ // Once again, Sass deviates from the spec and supplies the version as a
+ // string rather than a number, so we use loose equality checking here.
+ if (version != that._version) {
+ throw new Error('Unsupported version: ' + version)
+ }
+
+ if (sourceRoot) {
+ sourceRoot = util.normalize(sourceRoot)
+ }
+
+ sources = sources
+ .map(String)
+ // Some source maps produce relative source paths like "./foo.js" instead of
+ // "foo.js". Normalize these first so that future comparisons will succeed.
+ // See bugzil.la/1090768.
+ .map(util.normalize)
+ // Always ensure that absolute sources are internally stored relative to
+ // the source root, if the source root is absolute. Not doing this would
+ // be particularly problematic when the source root is a prefix of the
+ // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
+ .map(function (source) {
+ return sourceRoot &&
+ util.isAbsolute(sourceRoot) &&
+ util.isAbsolute(source)
+ ? util.relative(sourceRoot, source)
+ : source
+ })
+
+ // Pass `true` below to allow duplicate names and sources. While source maps
+ // are intended to be compressed and deduplicated, the TypeScript compiler
+ // sometimes generates source maps with duplicates in them. See Github issue
+ // #72 and bugzil.la/889492.
+ that._names = ArraySet.fromArray(names.map(String), true)
+ that._sources = ArraySet.fromArray(sources, true)
+
+ that._absoluteSources = that._sources.toArray().map(function (s) {
+ return util.computeSourceURL(sourceRoot, s, aSourceMapURL)
+ })
+
+ that.sourceRoot = sourceRoot
+ that.sourcesContent = sourcesContent
+ that._mappings = mappings
+ that._sourceMapURL = aSourceMapURL
+ that.file = file
+
+ that._computedColumnSpans = false
+ that._mappingsPtr = 0
+ that._wasm = null
+
+ return wasm().then((w) => {
+ that._wasm = w
+ return that
+ })
+ })
+ }
+
+ /**
+ * Utility function to find the index of a source. Returns -1 if not
+ * found.
+ */
+ _findSourceIndex(aSource) {
+ let relativeSource = aSource
+ if (this.sourceRoot != null) {
+ relativeSource = util.relative(this.sourceRoot, relativeSource)
+ }
+
+ if (this._sources.has(relativeSource)) {
+ return this._sources.indexOf(relativeSource)
+ }
+
+ // Maybe aSource is an absolute URL as returned by |sources|. In
+ // this case we can't simply undo the transform.
+ for (let i = 0; i < this._absoluteSources.length; ++i) {
+ if (this._absoluteSources[i] == aSource) {
+ return i
+ }
+ }
+
+ return -1
+ }
+
+ /**
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+ *
+ * @param SourceMapGenerator aSourceMap
+ * The source map that will be consumed.
+ * @param String aSourceMapURL
+ * The URL at which the source map can be found (optional)
+ * @returns BasicSourceMapConsumer
+ */
+ static fromSourceMap(aSourceMap, aSourceMapURL) {
+ return new BasicSourceMapConsumer(aSourceMap.toString())
+ }
+
+ get sources() {
+ return this._absoluteSources.slice()
+ }
+
+ _getMappingsPtr() {
+ if (this._mappingsPtr === 0) {
+ this._parseMappings(this._mappings, this.sourceRoot)
+ }
+
+ return this._mappingsPtr
+ }
+
+ /**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+ _parseMappings(aStr, aSourceRoot) {
+ const size = aStr.length
+
+ const mappingsBufPtr = this._wasm.exports.allocate_mappings(size)
+ const mappingsBuf = new Uint8Array(
+ this._wasm.exports.memory.buffer,
+ mappingsBufPtr,
+ size
+ )
+ for (let i = 0; i < size; i++) {
+ mappingsBuf[i] = aStr.charCodeAt(i)
+ }
+
+ const mappingsPtr = this._wasm.exports.parse_mappings(mappingsBufPtr)
+
+ if (!mappingsPtr) {
+ const error = this._wasm.exports.get_last_error()
+ let msg = `Error parsing mappings (code ${error}): `
+
+ // XXX: keep these error codes in sync with `fitzgen/source-map-mappings`.
+ switch (error) {
+ case 1:
+ msg +=
+ 'the mappings contained a negative line, column, source index, or name index'
+ break
+ case 2:
+ msg += 'the mappings contained a number larger than 2**32'
+ break
+ case 3:
+ msg += 'reached EOF while in the middle of parsing a VLQ'
+ break
+ case 4:
+ msg += 'invalid base 64 character while parsing a VLQ'
+ break
+ default:
+ msg += 'unknown error code'
+ break
+ }
+
+ throw new Error(msg)
+ }
+
+ this._mappingsPtr = mappingsPtr
+ }
+
+ eachMapping(aCallback, aContext, aOrder) {
+ const context = aContext || null
+ const order = aOrder || SourceMapConsumer.GENERATED_ORDER
+ const sourceRoot = this.sourceRoot
+
+ this._wasm.withMappingCallback(
+ (mapping) => {
+ if (mapping.source !== null) {
+ mapping.source = this._sources.at(mapping.source)
+ mapping.source = util.computeSourceURL(
+ sourceRoot,
+ mapping.source,
+ this._sourceMapURL
+ )
+
+ if (mapping.name !== null) {
+ mapping.name = this._names.at(mapping.name)
+ }
+ }
+
+ aCallback.call(context, mapping)
+ },
+ () => {
+ switch (order) {
+ case SourceMapConsumer.GENERATED_ORDER:
+ this._wasm.exports.by_generated_location(this._getMappingsPtr())
+ break
+ case SourceMapConsumer.ORIGINAL_ORDER:
+ this._wasm.exports.by_original_location(this._getMappingsPtr())
+ break
+ default:
+ throw new Error('Unknown order of iteration.')
+ }
+ }
+ )
+ }
+
+ allGeneratedPositionsFor(aArgs) {
+ let source = util.getArg(aArgs, 'source')
+ const originalLine = util.getArg(aArgs, 'line')
+ const originalColumn = aArgs.column || 0
+
+ source = this._findSourceIndex(source)
+ if (source < 0) {
+ return []
+ }
+
+ if (originalLine < 1) {
+ throw new Error('Line numbers must be >= 1')
+ }
+
+ if (originalColumn < 0) {
+ throw new Error('Column numbers must be >= 0')
+ }
+
+ const mappings = []
+
+ this._wasm.withMappingCallback(
+ (m) => {
+ let lastColumn = m.lastGeneratedColumn
+ if (this._computedColumnSpans && lastColumn === null) {
+ lastColumn = Infinity
+ }
+ mappings.push({
+ line: m.generatedLine,
+ column: m.generatedColumn,
+ lastColumn,
+ })
+ },
+ () => {
+ this._wasm.exports.all_generated_locations_for(
+ this._getMappingsPtr(),
+ source,
+ originalLine - 1,
+ 'column' in aArgs,
+ originalColumn
+ )
+ }
+ )
+
+ return mappings
+ }
+
+ destroy() {
+ if (this._mappingsPtr !== 0) {
+ this._wasm.exports.free_mappings(this._mappingsPtr)
+ this._mappingsPtr = 0
+ }
+ }
+
+ /**
+ * Compute the last column for each generated mapping. The last column is
+ * inclusive.
+ */
+ computeColumnSpans() {
+ if (this._computedColumnSpans) {
+ return
+ }
+
+ this._wasm.exports.compute_column_spans(this._getMappingsPtr())
+ this._computedColumnSpans = true
+ }
+
+ /**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ * - line: The line number in the generated source. The line number
+ * is 1-based.
+ * - column: The column number in the generated source. The column
+ * number is 0-based.
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ * closest element that is smaller than or greater than the one we are
+ * searching for, respectively, if the exact element cannot be found.
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - source: The original source file, or null.
+ * - line: The line number in the original source, or null. The
+ * line number is 1-based.
+ * - column: The column number in the original source, or null. The
+ * column number is 0-based.
+ * - name: The original identifier, or null.
+ */
+ originalPositionFor(aArgs) {
+ const needle = {
+ generatedLine: util.getArg(aArgs, 'line'),
+ generatedColumn: util.getArg(aArgs, 'column'),
+ }
+
+ if (needle.generatedLine < 1) {
+ throw new Error('Line numbers must be >= 1')
+ }
+
+ if (needle.generatedColumn < 0) {
+ throw new Error('Column numbers must be >= 0')
+ }
+
+ let bias = util.getArg(
+ aArgs,
+ 'bias',
+ SourceMapConsumer.GREATEST_LOWER_BOUND
+ )
+ if (bias == null) {
+ bias = SourceMapConsumer.GREATEST_LOWER_BOUND
+ }
+
+ let mapping
+ this._wasm.withMappingCallback(
+ (m) => (mapping = m),
+ () => {
+ this._wasm.exports.original_location_for(
+ this._getMappingsPtr(),
+ needle.generatedLine - 1,
+ needle.generatedColumn,
+ bias
+ )
+ }
+ )
+
+ if (mapping) {
+ if (mapping.generatedLine === needle.generatedLine) {
+ let source = util.getArg(mapping, 'source', null)
+ if (source !== null) {
+ source = this._sources.at(source)
+ source = util.computeSourceURL(
+ this.sourceRoot,
+ source,
+ this._sourceMapURL
+ )
+ }
+
+ let name = util.getArg(mapping, 'name', null)
+ if (name !== null) {
+ name = this._names.at(name)
+ }
+
+ return {
+ source,
+ line: util.getArg(mapping, 'originalLine', null),
+ column: util.getArg(mapping, 'originalColumn', null),
+ name,
+ }
+ }
+ }
+
+ return {
+ source: null,
+ line: null,
+ column: null,
+ name: null,
+ }
+ }
+
+ /**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+ hasContentsOfAllSources() {
+ if (!this.sourcesContent) {
+ return false
+ }
+ return (
+ this.sourcesContent.length >= this._sources.size() &&
+ !this.sourcesContent.some(function (sc) {
+ return sc == null
+ })
+ )
+ }
+
+ /**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+ sourceContentFor(aSource, nullOnMissing) {
+ if (!this.sourcesContent) {
+ return null
+ }
+
+ const index = this._findSourceIndex(aSource)
+ if (index >= 0) {
+ return this.sourcesContent[index]
+ }
+
+ let relativeSource = aSource
+ if (this.sourceRoot != null) {
+ relativeSource = util.relative(this.sourceRoot, relativeSource)
+ }
+
+ let url
+ if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
+ // XXX: file:// URIs and absolute paths lead to unexpected behavior for
+ // many users. We can help them out when they expect file:// URIs to
+ // behave like it would if they were running a local HTTP server. See
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
+ const fileUriAbsPath = relativeSource.replace(/^file:\/\//, '')
+ if (url.scheme == 'file' && this._sources.has(fileUriAbsPath)) {
+ return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
+ }
+
+ if (
+ (!url.path || url.path == '/') &&
+ this._sources.has('/' + relativeSource)
+ ) {
+ return this.sourcesContent[this._sources.indexOf('/' + relativeSource)]
+ }
+ }
+
+ // This function is used recursively from
+ // IndexedSourceMapConsumer.prototype.sourceContentFor. In that case, we
+ // don't want to throw if we can't find the source - we just want to
+ // return null, so we provide a flag to exit gracefully.
+ if (nullOnMissing) {
+ return null
+ }
+
+ throw new Error('"' + relativeSource + '" is not in the SourceMap.')
+ }
+
+ /**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source. The line number
+ * is 1-based.
+ * - column: The column number in the original source. The column
+ * number is 0-based.
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ * closest element that is smaller than or greater than the one we are
+ * searching for, respectively, if the exact element cannot be found.
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - line: The line number in the generated source, or null. The
+ * line number is 1-based.
+ * - column: The column number in the generated source, or null.
+ * The column number is 0-based.
+ */
+ generatedPositionFor(aArgs) {
+ let source = util.getArg(aArgs, 'source')
+ source = this._findSourceIndex(source)
+ if (source < 0) {
+ return {
+ line: null,
+ column: null,
+ lastColumn: null,
+ }
+ }
+
+ const needle = {
+ source,
+ originalLine: util.getArg(aArgs, 'line'),
+ originalColumn: util.getArg(aArgs, 'column'),
+ }
+
+ if (needle.originalLine < 1) {
+ throw new Error('Line numbers must be >= 1')
+ }
+
+ if (needle.originalColumn < 0) {
+ throw new Error('Column numbers must be >= 0')
+ }
+
+ let bias = util.getArg(
+ aArgs,
+ 'bias',
+ SourceMapConsumer.GREATEST_LOWER_BOUND
+ )
+ if (bias == null) {
+ bias = SourceMapConsumer.GREATEST_LOWER_BOUND
+ }
+
+ let mapping
+ this._wasm.withMappingCallback(
+ (m) => (mapping = m),
+ () => {
+ this._wasm.exports.generated_location_for(
+ this._getMappingsPtr(),
+ needle.source,
+ needle.originalLine - 1,
+ needle.originalColumn,
+ bias
+ )
+ }
+ )
+
+ if (mapping) {
+ if (mapping.source === needle.source) {
+ let lastColumn = mapping.lastGeneratedColumn
+ if (this._computedColumnSpans && lastColumn === null) {
+ lastColumn = Infinity
+ }
+ return {
+ line: util.getArg(mapping, 'generatedLine', null),
+ column: util.getArg(mapping, 'generatedColumn', null),
+ lastColumn,
+ }
+ }
+ }
+
+ return {
+ line: null,
+ column: null,
+ lastColumn: null,
+ }
+ }
+}
+
+BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer
+exports.BasicSourceMapConsumer = BasicSourceMapConsumer
+
+/**
+ * An IndexedSourceMapConsumer instance represents a parsed source map which
+ * we can query for information. It differs from BasicSourceMapConsumer in
+ * that it takes "indexed" source maps (i.e. ones with a "sections" field) as
+ * input.
+ *
+ * The first parameter is a raw source map (either as a JSON string, or already
+ * parsed to an object). According to the spec for indexed source maps, they
+ * have the following attributes:
+ *
+ * - version: Which version of the source map spec this map is following.
+ * - file: Optional. The generated file this source map is associated with.
+ * - sections: A list of section definitions.
+ *
+ * Each value under the "sections" field has two fields:
+ * - offset: The offset into the original specified at which this section
+ * begins to apply, defined as an object with a "line" and "column"
+ * field.
+ * - map: A source map definition. This source map could also be indexed,
+ * but doesn't have to be.
+ *
+ * Instead of the "map" field, it's also possible to have a "url" field
+ * specifying a URL to retrieve a source map from, but that's currently
+ * unsupported.
+ *
+ * Here's an example source map, taken from the source map spec[0], but
+ * modified to omit a section which uses the "url" field.
+ *
+ * {
+ * version : 3,
+ * file: "app.js",
+ * sections: [{
+ * offset: {line:100, column:10},
+ * map: {
+ * version : 3,
+ * file: "section.js",
+ * sources: ["foo.js", "bar.js"],
+ * names: ["src", "maps", "are", "fun"],
+ * mappings: "AAAA,E;;ABCDE;"
+ * }
+ * }],
+ * }
+ *
+ * The second parameter, if given, is a string whose value is the URL
+ * at which the source map was found. This URL is used to compute the
+ * sources array.
+ *
+ * [0]: https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt
+ */
+class IndexedSourceMapConsumer extends SourceMapConsumer {
+ constructor(aSourceMap, aSourceMapURL) {
+ return super(INTERNAL).then((that) => {
+ let sourceMap = aSourceMap
+ if (typeof aSourceMap === 'string') {
+ sourceMap = util.parseSourceMapInput(aSourceMap)
+ }
+
+ const version = util.getArg(sourceMap, 'version')
+ const sections = util.getArg(sourceMap, 'sections')
+
+ if (version != that._version) {
+ throw new Error('Unsupported version: ' + version)
+ }
+
+ that._sources = new ArraySet()
+ that._names = new ArraySet()
+ that.__generatedMappings = null
+ that.__originalMappings = null
+ that.__generatedMappingsUnsorted = null
+ that.__originalMappingsUnsorted = null
+
+ let lastOffset = {
+ line: -1,
+ column: 0,
+ }
+ return Promise.all(
+ sections.map((s) => {
+ if (s.url) {
+ // The url field will require support for asynchronicity.
+ // See https://github.com/mozilla/source-map/issues/16
+ throw new Error(
+ 'Support for url field in sections not implemented.'
+ )
+ }
+ const offset = util.getArg(s, 'offset')
+ const offsetLine = util.getArg(offset, 'line')
+ const offsetColumn = util.getArg(offset, 'column')
+
+ if (
+ offsetLine < lastOffset.line ||
+ (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)
+ ) {
+ throw new Error(
+ 'Section offsets must be ordered and non-overlapping.'
+ )
+ }
+ lastOffset = offset
+
+ const cons = new SourceMapConsumer(
+ util.getArg(s, 'map'),
+ aSourceMapURL
+ )
+ return cons.then((consumer) => {
+ return {
+ generatedOffset: {
+ // The offset fields are 0-based, but we use 1-based indices when
+ // encoding/decoding from VLQ.
+ generatedLine: offsetLine + 1,
+ generatedColumn: offsetColumn + 1,
+ },
+ consumer,
+ }
+ })
+ })
+ ).then((s) => {
+ that._sections = s
+ return that
+ })
+ })
+ }
+
+ // `__generatedMappings` and `__originalMappings` are arrays that hold the
+ // parsed mapping coordinates from the source map's "mappings" attribute. They
+ // are lazily instantiated, accessed via the `_generatedMappings` and
+ // `_originalMappings` getters respectively, and we only parse the mappings
+ // and create these arrays once queried for a source location. We jump through
+ // these hoops because there can be many thousands of mappings, and parsing
+ // them is expensive, so we only want to do it if we must.
+ //
+ // Each object in the arrays is of the form:
+ //
+ // {
+ // generatedLine: The line number in the generated code,
+ // generatedColumn: The column number in the generated code,
+ // source: The path to the original source file that generated this
+ // chunk of code,
+ // originalLine: The line number in the original source that
+ // corresponds to this chunk of generated code,
+ // originalColumn: The column number in the original source that
+ // corresponds to this chunk of generated code,
+ // name: The name of the original symbol which generated this chunk of
+ // code.
+ // }
+ //
+ // All properties except for `generatedLine` and `generatedColumn` can be
+ // `null`.
+ //
+ // `_generatedMappings` is ordered by the generated positions.
+ //
+ // `_originalMappings` is ordered by the original positions.
+ get _generatedMappings() {
+ if (!this.__generatedMappings) {
+ this._sortGeneratedMappings()
+ }
+
+ return this.__generatedMappings
+ }
+
+ get _originalMappings() {
+ if (!this.__originalMappings) {
+ this._sortOriginalMappings()
+ }
+
+ return this.__originalMappings
+ }
+
+ get _generatedMappingsUnsorted() {
+ if (!this.__generatedMappingsUnsorted) {
+ this._parseMappings(this._mappings, this.sourceRoot)
+ }
+
+ return this.__generatedMappingsUnsorted
+ }
+
+ get _originalMappingsUnsorted() {
+ if (!this.__originalMappingsUnsorted) {
+ this._parseMappings(this._mappings, this.sourceRoot)
+ }
+
+ return this.__originalMappingsUnsorted
+ }
+
+ _sortGeneratedMappings() {
+ const mappings = this._generatedMappingsUnsorted
+ mappings.sort(util.compareByGeneratedPositionsDeflated)
+ this.__generatedMappings = mappings
+ }
+
+ _sortOriginalMappings() {
+ const mappings = this._originalMappingsUnsorted
+ mappings.sort(util.compareByOriginalPositions)
+ this.__originalMappings = mappings
+ }
+
+ /**
+ * The list of original sources.
+ */
+ get sources() {
+ const sources = []
+ for (let i = 0; i < this._sections.length; i++) {
+ for (let j = 0; j < this._sections[i].consumer.sources.length; j++) {
+ sources.push(this._sections[i].consumer.sources[j])
+ }
+ }
+ return sources
+ }
+
+ /**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ * - line: The line number in the generated source. The line number
+ * is 1-based.
+ * - column: The column number in the generated source. The column
+ * number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - source: The original source file, or null.
+ * - line: The line number in the original source, or null. The
+ * line number is 1-based.
+ * - column: The column number in the original source, or null. The
+ * column number is 0-based.
+ * - name: The original identifier, or null.
+ */
+ originalPositionFor(aArgs) {
+ const needle = {
+ generatedLine: util.getArg(aArgs, 'line'),
+ generatedColumn: util.getArg(aArgs, 'column'),
+ }
+
+ // Find the section containing the generated position we're trying to map
+ // to an original position.
+ const sectionIndex = binarySearch.search(
+ needle,
+ this._sections,
+ function (aNeedle, section) {
+ const cmp =
+ aNeedle.generatedLine - section.generatedOffset.generatedLine
+ if (cmp) {
+ return cmp
+ }
+
+ return aNeedle.generatedColumn - section.generatedOffset.generatedColumn
+ }
+ )
+ const section = this._sections[sectionIndex]
+
+ if (!section) {
+ return {
+ source: null,
+ line: null,
+ column: null,
+ name: null,
+ }
+ }
+
+ return section.consumer.originalPositionFor({
+ line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+ column:
+ needle.generatedColumn -
+ (section.generatedOffset.generatedLine === needle.generatedLine
+ ? section.generatedOffset.generatedColumn - 1
+ : 0),
+ bias: aArgs.bias,
+ })
+ }
+
+ /**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+ hasContentsOfAllSources() {
+ return this._sections.every(function (s) {
+ return s.consumer.hasContentsOfAllSources()
+ })
+ }
+
+ /**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+ sourceContentFor(aSource, nullOnMissing) {
+ for (let i = 0; i < this._sections.length; i++) {
+ const section = this._sections[i]
+
+ const content = section.consumer.sourceContentFor(aSource, true)
+ if (content) {
+ return content
+ }
+ }
+ if (nullOnMissing) {
+ return null
+ }
+ throw new Error('"' + aSource + '" is not in the SourceMap.')
+ }
+
+ /**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source. The line number
+ * is 1-based.
+ * - column: The column number in the original source. The column
+ * number is 0-based.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - line: The line number in the generated source, or null. The
+ * line number is 1-based.
+ * - column: The column number in the generated source, or null.
+ * The column number is 0-based.
+ */
+ generatedPositionFor(aArgs) {
+ for (let i = 0; i < this._sections.length; i++) {
+ const section = this._sections[i]
+
+ // Only consider this section if the requested source is in the list of
+ // sources of the consumer.
+ if (
+ section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1
+ ) {
+ continue
+ }
+ const generatedPosition = section.consumer.generatedPositionFor(aArgs)
+ if (generatedPosition) {
+ const ret = {
+ line:
+ generatedPosition.line +
+ (section.generatedOffset.generatedLine - 1),
+ column:
+ generatedPosition.column +
+ (section.generatedOffset.generatedLine === generatedPosition.line
+ ? section.generatedOffset.generatedColumn - 1
+ : 0),
+ }
+ return ret
+ }
+ }
+
+ return {
+ line: null,
+ column: null,
+ }
+ }
+
+ /**
+ * Parse the mappings in a string in to a data structure which we can easily
+ * query (the ordered arrays in the `this.__generatedMappings` and
+ * `this.__originalMappings` properties).
+ */
+ _parseMappings(aStr, aSourceRoot) {
+ const generatedMappings = (this.__generatedMappingsUnsorted = [])
+ const originalMappings = (this.__originalMappingsUnsorted = [])
+ for (let i = 0; i < this._sections.length; i++) {
+ const section = this._sections[i]
+
+ const sectionMappings = []
+ section.consumer.eachMapping((m) => sectionMappings.push(m))
+
+ for (let j = 0; j < sectionMappings.length; j++) {
+ const mapping = sectionMappings[j]
+
+ // TODO: test if null is correct here. The original code used
+ // `source`, which would actually have gotten used as null because
+ // var's get hoisted.
+ // See: https://github.com/mozilla/source-map/issues/333
+ let source = util.computeSourceURL(
+ section.consumer.sourceRoot,
+ null,
+ this._sourceMapURL
+ )
+ this._sources.add(source)
+ source = this._sources.indexOf(source)
+
+ let name = null
+ if (mapping.name) {
+ this._names.add(mapping.name)
+ name = this._names.indexOf(mapping.name)
+ }
+
+ // The mappings coming from the consumer for the section have
+ // generated positions relative to the start of the section, so we
+ // need to offset them to be relative to the start of the concatenated
+ // generated file.
+ const adjustedMapping = {
+ source,
+ generatedLine:
+ mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+ generatedColumn:
+ mapping.generatedColumn +
+ (section.generatedOffset.generatedLine === mapping.generatedLine
+ ? section.generatedOffset.generatedColumn - 1
+ : 0),
+ originalLine: mapping.originalLine,
+ originalColumn: mapping.originalColumn,
+ name,
+ }
+
+ generatedMappings.push(adjustedMapping)
+ if (typeof adjustedMapping.originalLine === 'number') {
+ originalMappings.push(adjustedMapping)
+ }
+ }
+ }
+ }
+
+ eachMapping(aCallback, aContext, aOrder) {
+ const context = aContext || null
+ const order = aOrder || SourceMapConsumer.GENERATED_ORDER
+
+ let mappings
+ switch (order) {
+ case SourceMapConsumer.GENERATED_ORDER:
+ mappings = this._generatedMappings
+ break
+ case SourceMapConsumer.ORIGINAL_ORDER:
+ mappings = this._originalMappings
+ break
+ default:
+ throw new Error('Unknown order of iteration.')
+ }
+
+ const sourceRoot = this.sourceRoot
+ mappings
+ .map(function (mapping) {
+ let source = null
+ if (mapping.source !== null) {
+ source = this._sources.at(mapping.source)
+ source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL)
+ }
+ return {
+ source,
+ generatedLine: mapping.generatedLine,
+ generatedColumn: mapping.generatedColumn,
+ originalLine: mapping.originalLine,
+ originalColumn: mapping.originalColumn,
+ name: mapping.name === null ? null : this._names.at(mapping.name),
+ }
+ }, this)
+ .forEach(aCallback, context)
+ }
+
+ /**
+ * Find the mapping that best matches the hypothetical "needle" mapping that
+ * we are searching for in the given "haystack" of mappings.
+ */
+ _findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
+ // To return the position we are searching for, we must first find the
+ // mapping for the given position and then return the opposite position it
+ // points to. Because the mappings are sorted, we can use binary search to
+ // find the best mapping.
+
+ if (aNeedle[aLineName] <= 0) {
+ throw new TypeError(
+ 'Line must be greater than or equal to 1, got ' + aNeedle[aLineName]
+ )
+ }
+ if (aNeedle[aColumnName] < 0) {
+ throw new TypeError(
+ 'Column must be greater than or equal to 0, got ' + aNeedle[aColumnName]
+ )
+ }
+
+ return binarySearch.search(aNeedle, aMappings, aComparator, aBias)
+ }
+
+ allGeneratedPositionsFor(aArgs) {
+ const line = util.getArg(aArgs, 'line')
+
+ // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
+ // returns the index of the closest mapping less than the needle. By
+ // setting needle.originalColumn to 0, we thus find the last mapping for
+ // the given line, provided such a mapping exists.
+ const needle = {
+ source: util.getArg(aArgs, 'source'),
+ originalLine: line,
+ originalColumn: util.getArg(aArgs, 'column', 0),
+ }
+
+ needle.source = this._findSourceIndex(needle.source)
+ if (needle.source < 0) {
+ return []
+ }
+
+ if (needle.originalLine < 1) {
+ throw new Error('Line numbers must be >= 1')
+ }
+
+ if (needle.originalColumn < 0) {
+ throw new Error('Column numbers must be >= 0')
+ }
+
+ const mappings = []
+
+ let index = this._findMapping(
+ needle,
+ this._originalMappings,
+ 'originalLine',
+ 'originalColumn',
+ util.compareByOriginalPositions,
+ binarySearch.LEAST_UPPER_BOUND
+ )
+ if (index >= 0) {
+ let mapping = this._originalMappings[index]
+
+ if (aArgs.column === undefined) {
+ const originalLine = mapping.originalLine
+
+ // Iterate until either we run out of mappings, or we run into
+ // a mapping for a different line than the one we found. Since
+ // mappings are sorted, this is guaranteed to find all mappings for
+ // the line we found.
+ while (mapping && mapping.originalLine === originalLine) {
+ let lastColumn = mapping.lastGeneratedColumn
+ if (this._computedColumnSpans && lastColumn === null) {
+ lastColumn = Infinity
+ }
+ mappings.push({
+ line: util.getArg(mapping, 'generatedLine', null),
+ column: util.getArg(mapping, 'generatedColumn', null),
+ lastColumn,
+ })
+
+ mapping = this._originalMappings[++index]
+ }
+ } else {
+ const originalColumn = mapping.originalColumn
+
+ // Iterate until either we run out of mappings, or we run into
+ // a mapping for a different line than the one we were searching for.
+ // Since mappings are sorted, this is guaranteed to find all mappings for
+ // the line we are searching for.
+ while (
+ mapping &&
+ mapping.originalLine === line &&
+ mapping.originalColumn == originalColumn
+ ) {
+ let lastColumn = mapping.lastGeneratedColumn
+ if (this._computedColumnSpans && lastColumn === null) {
+ lastColumn = Infinity
+ }
+ mappings.push({
+ line: util.getArg(mapping, 'generatedLine', null),
+ column: util.getArg(mapping, 'generatedColumn', null),
+ lastColumn,
+ })
+
+ mapping = this._originalMappings[++index]
+ }
+ }
+ }
+
+ return mappings
+ }
+
+ destroy() {
+ for (let i = 0; i < this._sections.length; i++) {
+ this._sections[i].consumer.destroy()
+ }
+ }
+}
+exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer
+
+/*
+ * Cheat to get around inter-twingled classes. `factory()` can be at the end
+ * where it has access to non-hoisted classes, but it gets hoisted itself.
+ */
+function _factory(aSourceMap, aSourceMapURL) {
+ let sourceMap = aSourceMap
+ if (typeof aSourceMap === 'string') {
+ sourceMap = util.parseSourceMapInput(aSourceMap)
+ }
+
+ const consumer =
+ sourceMap.sections != null
+ ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
+ : new BasicSourceMapConsumer(sourceMap, aSourceMapURL)
+ return Promise.resolve(consumer)
+}
+
+function _factoryBSM(aSourceMap, aSourceMapURL) {
+ return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL)
+}
diff --git a/packages/uni-stacktracey/lib/source-map/lib/source-map-generator.js b/packages/uni-stacktracey/lib/source-map/lib/source-map-generator.js
new file mode 100644
index 000000000..af972408e
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/source-map-generator.js
@@ -0,0 +1,439 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+const base64VLQ = require('./base64-vlq')
+const util = require('./util')
+const ArraySet = require('./array-set').ArraySet
+const MappingList = require('./mapping-list').MappingList
+
+/**
+ * An instance of the SourceMapGenerator represents a source map which is
+ * being built incrementally. You may pass an object with the following
+ * properties:
+ *
+ * - file: The filename of the generated source.
+ * - sourceRoot: A root for all relative URLs in this source map.
+ */
+class SourceMapGenerator {
+ constructor(aArgs) {
+ if (!aArgs) {
+ aArgs = {}
+ }
+ this._file = util.getArg(aArgs, 'file', null)
+ this._sourceRoot = util.getArg(aArgs, 'sourceRoot', null)
+ this._skipValidation = util.getArg(aArgs, 'skipValidation', false)
+ this._sources = new ArraySet()
+ this._names = new ArraySet()
+ this._mappings = new MappingList()
+ this._sourcesContents = null
+ }
+
+ /**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param aSourceMapConsumer The SourceMap.
+ */
+ static fromSourceMap(aSourceMapConsumer) {
+ const sourceRoot = aSourceMapConsumer.sourceRoot
+ const generator = new SourceMapGenerator({
+ file: aSourceMapConsumer.file,
+ sourceRoot,
+ })
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ const newMapping = {
+ generated: {
+ line: mapping.generatedLine,
+ column: mapping.generatedColumn,
+ },
+ }
+
+ if (mapping.source != null) {
+ newMapping.source = mapping.source
+ if (sourceRoot != null) {
+ newMapping.source = util.relative(sourceRoot, newMapping.source)
+ }
+
+ newMapping.original = {
+ line: mapping.originalLine,
+ column: mapping.originalColumn,
+ }
+
+ if (mapping.name != null) {
+ newMapping.name = mapping.name
+ }
+ }
+
+ generator.addMapping(newMapping)
+ })
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ let sourceRelative = sourceFile
+ if (sourceRoot !== null) {
+ sourceRelative = util.relative(sourceRoot, sourceFile)
+ }
+
+ if (!generator._sources.has(sourceRelative)) {
+ generator._sources.add(sourceRelative)
+ }
+
+ const content = aSourceMapConsumer.sourceContentFor(sourceFile)
+ if (content != null) {
+ generator.setSourceContent(sourceFile, content)
+ }
+ })
+ return generator
+ }
+
+ /**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ * - generated: An object with the generated line and column positions.
+ * - original: An object with the original line and column positions.
+ * - source: The original source file (relative to the sourceRoot).
+ * - name: An optional original token name for this mapping.
+ */
+ addMapping(aArgs) {
+ const generated = util.getArg(aArgs, 'generated')
+ const original = util.getArg(aArgs, 'original', null)
+ let source = util.getArg(aArgs, 'source', null)
+ let name = util.getArg(aArgs, 'name', null)
+
+ if (!this._skipValidation) {
+ this._validateMapping(generated, original, source, name)
+ }
+
+ if (source != null) {
+ source = String(source)
+ if (!this._sources.has(source)) {
+ this._sources.add(source)
+ }
+ }
+
+ if (name != null) {
+ name = String(name)
+ if (!this._names.has(name)) {
+ this._names.add(name)
+ }
+ }
+
+ this._mappings.add({
+ generatedLine: generated.line,
+ generatedColumn: generated.column,
+ originalLine: original != null && original.line,
+ originalColumn: original != null && original.column,
+ source,
+ name,
+ })
+ }
+
+ /**
+ * Set the source content for a source file.
+ */
+ setSourceContent(aSourceFile, aSourceContent) {
+ let source = aSourceFile
+ if (this._sourceRoot != null) {
+ source = util.relative(this._sourceRoot, source)
+ }
+
+ if (aSourceContent != null) {
+ // Add the source content to the _sourcesContents map.
+ // Create a new _sourcesContents map if the property is null.
+ if (!this._sourcesContents) {
+ this._sourcesContents = Object.create(null)
+ }
+ this._sourcesContents[util.toSetString(source)] = aSourceContent
+ } else if (this._sourcesContents) {
+ // Remove the source file from the _sourcesContents map.
+ // If the _sourcesContents map is empty, set the property to null.
+ delete this._sourcesContents[util.toSetString(source)]
+ if (Object.keys(this._sourcesContents).length === 0) {
+ this._sourcesContents = null
+ }
+ }
+ }
+
+ /**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param aSourceMapConsumer The source map to be applied.
+ * @param aSourceFile Optional. The filename of the source file.
+ * If omitted, SourceMapConsumer's file property will be used.
+ * @param aSourceMapPath Optional. The dirname of the path to the source map
+ * to be applied. If relative, it is relative to the SourceMapConsumer.
+ * This parameter is needed when the two source maps aren't in the same
+ * directory, and the source map to be applied contains relative source
+ * paths. If so, those relative source paths need to be rewritten
+ * relative to the SourceMapGenerator.
+ */
+ applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+ let sourceFile = aSourceFile
+ // If aSourceFile is omitted, we will use the file property of the SourceMap
+ if (aSourceFile == null) {
+ if (aSourceMapConsumer.file == null) {
+ throw new Error(
+ 'SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, ' +
+ 'or the source map\'s "file" property. Both were omitted.'
+ )
+ }
+ sourceFile = aSourceMapConsumer.file
+ }
+ const sourceRoot = this._sourceRoot
+ // Make "sourceFile" relative if an absolute Url is passed.
+ if (sourceRoot != null) {
+ sourceFile = util.relative(sourceRoot, sourceFile)
+ }
+ // Applying the SourceMap can add and remove items from the sources and
+ // the names array.
+ const newSources =
+ this._mappings.toArray().length > 0 ? new ArraySet() : this._sources
+ const newNames = new ArraySet()
+
+ // Find mappings for the "sourceFile"
+ this._mappings.unsortedForEach(function (mapping) {
+ if (mapping.source === sourceFile && mapping.originalLine != null) {
+ // Check if it can be mapped by the source map, then update the mapping.
+ const original = aSourceMapConsumer.originalPositionFor({
+ line: mapping.originalLine,
+ column: mapping.originalColumn,
+ })
+ if (original.source != null) {
+ // Copy mapping
+ mapping.source = original.source
+ if (aSourceMapPath != null) {
+ mapping.source = util.join(aSourceMapPath, mapping.source)
+ }
+ if (sourceRoot != null) {
+ mapping.source = util.relative(sourceRoot, mapping.source)
+ }
+ mapping.originalLine = original.line
+ mapping.originalColumn = original.column
+ if (original.name != null) {
+ mapping.name = original.name
+ }
+ }
+ }
+
+ const source = mapping.source
+ if (source != null && !newSources.has(source)) {
+ newSources.add(source)
+ }
+
+ const name = mapping.name
+ if (name != null && !newNames.has(name)) {
+ newNames.add(name)
+ }
+ }, this)
+ this._sources = newSources
+ this._names = newNames
+
+ // Copy sourcesContents of applied map.
+ aSourceMapConsumer.sources.forEach(function (srcFile) {
+ const content = aSourceMapConsumer.sourceContentFor(srcFile)
+ if (content != null) {
+ if (aSourceMapPath != null) {
+ srcFile = util.join(aSourceMapPath, srcFile)
+ }
+ if (sourceRoot != null) {
+ srcFile = util.relative(sourceRoot, srcFile)
+ }
+ this.setSourceContent(srcFile, content)
+ }
+ }, this)
+ }
+
+ /**
+ * A mapping can have one of the three levels of data:
+ *
+ * 1. Just the generated position.
+ * 2. The Generated position, original position, and original source.
+ * 3. Generated and original position, original source, as well as a name
+ * token.
+ *
+ * To maintain consistency, we validate that any new mapping being added falls
+ * in to one of these categories.
+ */
+ _validateMapping(aGenerated, aOriginal, aSource, aName) {
+ // When aOriginal is truthy but has empty values for .line and .column,
+ // it is most likely a programmer error. In this case we throw a very
+ // specific error message to try to guide them the right way.
+ // For example: https://github.com/Polymer/polymer-bundler/pull/519
+ if (
+ aOriginal &&
+ typeof aOriginal.line !== 'number' &&
+ typeof aOriginal.column !== 'number'
+ ) {
+ throw new Error(
+ 'original.line and original.column are not numbers -- you probably meant to omit ' +
+ 'the original mapping entirely and only map the generated position. If so, pass ' +
+ 'null for the original mapping instead of an object with empty or null values.'
+ )
+ }
+
+ if (
+ aGenerated &&
+ 'line' in aGenerated &&
+ 'column' in aGenerated &&
+ aGenerated.line > 0 &&
+ aGenerated.column >= 0 &&
+ !aOriginal &&
+ !aSource &&
+ !aName
+ ) {
+ // Case 1.
+ } else if (
+ aGenerated &&
+ 'line' in aGenerated &&
+ 'column' in aGenerated &&
+ aOriginal &&
+ 'line' in aOriginal &&
+ 'column' in aOriginal &&
+ aGenerated.line > 0 &&
+ aGenerated.column >= 0 &&
+ aOriginal.line > 0 &&
+ aOriginal.column >= 0 &&
+ aSource
+ ) {
+ // Cases 2 and 3.
+ } else {
+ throw new Error(
+ 'Invalid mapping: ' +
+ JSON.stringify({
+ generated: aGenerated,
+ source: aSource,
+ original: aOriginal,
+ name: aName,
+ })
+ )
+ }
+ }
+
+ /**
+ * Serialize the accumulated mappings in to the stream of base 64 VLQs
+ * specified by the source map format.
+ */
+ _serializeMappings() {
+ let previousGeneratedColumn = 0
+ let previousGeneratedLine = 1
+ let previousOriginalColumn = 0
+ let previousOriginalLine = 0
+ let previousName = 0
+ let previousSource = 0
+ let result = ''
+ let next
+ let mapping
+ let nameIdx
+ let sourceIdx
+
+ const mappings = this._mappings.toArray()
+ for (let i = 0, len = mappings.length; i < len; i++) {
+ mapping = mappings[i]
+ next = ''
+
+ if (mapping.generatedLine !== previousGeneratedLine) {
+ previousGeneratedColumn = 0
+ while (mapping.generatedLine !== previousGeneratedLine) {
+ next += ';'
+ previousGeneratedLine++
+ }
+ } else if (i > 0) {
+ if (
+ !util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])
+ ) {
+ continue
+ }
+ next += ','
+ }
+
+ next += base64VLQ.encode(
+ mapping.generatedColumn - previousGeneratedColumn
+ )
+ previousGeneratedColumn = mapping.generatedColumn
+
+ if (mapping.source != null) {
+ sourceIdx = this._sources.indexOf(mapping.source)
+ next += base64VLQ.encode(sourceIdx - previousSource)
+ previousSource = sourceIdx
+
+ // lines are stored 0-based in SourceMap spec version 3
+ next += base64VLQ.encode(
+ mapping.originalLine - 1 - previousOriginalLine
+ )
+ previousOriginalLine = mapping.originalLine - 1
+
+ next += base64VLQ.encode(
+ mapping.originalColumn - previousOriginalColumn
+ )
+ previousOriginalColumn = mapping.originalColumn
+
+ if (mapping.name != null) {
+ nameIdx = this._names.indexOf(mapping.name)
+ next += base64VLQ.encode(nameIdx - previousName)
+ previousName = nameIdx
+ }
+ }
+
+ result += next
+ }
+
+ return result
+ }
+
+ _generateSourcesContent(aSources, aSourceRoot) {
+ return aSources.map(function (source) {
+ if (!this._sourcesContents) {
+ return null
+ }
+ if (aSourceRoot != null) {
+ source = util.relative(aSourceRoot, source)
+ }
+ const key = util.toSetString(source)
+ return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
+ ? this._sourcesContents[key]
+ : null
+ }, this)
+ }
+
+ /**
+ * Externalize the source map.
+ */
+ toJSON() {
+ const map = {
+ version: this._version,
+ sources: this._sources.toArray(),
+ names: this._names.toArray(),
+ mappings: this._serializeMappings(),
+ }
+ if (this._file != null) {
+ map.file = this._file
+ }
+ if (this._sourceRoot != null) {
+ map.sourceRoot = this._sourceRoot
+ }
+ if (this._sourcesContents) {
+ map.sourcesContent = this._generateSourcesContent(
+ map.sources,
+ map.sourceRoot
+ )
+ }
+
+ return map
+ }
+
+ /**
+ * Render the source map being generated to a string.
+ */
+ toString() {
+ return JSON.stringify(this.toJSON())
+ }
+}
+
+SourceMapGenerator.prototype._version = 3
+exports.SourceMapGenerator = SourceMapGenerator
diff --git a/packages/uni-stacktracey/lib/source-map/lib/source-node.js b/packages/uni-stacktracey/lib/source-map/lib/source-node.js
new file mode 100644
index 000000000..afeb6a79d
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/source-node.js
@@ -0,0 +1,430 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+const SourceMapGenerator = require('./source-map-generator').SourceMapGenerator
+const util = require('./util')
+
+// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
+// operating systems these days (capturing the result).
+const REGEX_NEWLINE = /(\r?\n)/
+
+// Newline character code for charCodeAt() comparisons
+const NEWLINE_CODE = 10
+
+// Private symbol for identifying `SourceNode`s when multiple versions of
+// the source-map library are loaded. This MUST NOT CHANGE across
+// versions!
+const isSourceNode = '$$$isSourceNode$$$'
+
+/**
+ * SourceNodes provide a way to abstract over interpolating/concatenating
+ * snippets of generated JavaScript source code while maintaining the line and
+ * column information associated with the original source code.
+ *
+ * @param aLine The original line number.
+ * @param aColumn The original column number.
+ * @param aSource The original source's filename.
+ * @param aChunks Optional. An array of strings which are snippets of
+ * generated JS, or other SourceNodes.
+ * @param aName The original identifier.
+ */
+class SourceNode {
+ constructor(aLine, aColumn, aSource, aChunks, aName) {
+ this.children = []
+ this.sourceContents = {}
+ this.line = aLine == null ? null : aLine
+ this.column = aColumn == null ? null : aColumn
+ this.source = aSource == null ? null : aSource
+ this.name = aName == null ? null : aName
+ this[isSourceNode] = true
+ if (aChunks != null) this.add(aChunks)
+ }
+
+ /**
+ * Creates a SourceNode from generated code and a SourceMapConsumer.
+ *
+ * @param aGeneratedCode The generated code
+ * @param aSourceMapConsumer The SourceMap for the generated code
+ * @param aRelativePath Optional. The path that relative sources in the
+ * SourceMapConsumer should be relative to.
+ */
+ static fromStringWithSourceMap(
+ aGeneratedCode,
+ aSourceMapConsumer,
+ aRelativePath
+ ) {
+ // The SourceNode we want to fill with the generated code
+ // and the SourceMap
+ const node = new SourceNode()
+
+ // All even indices of this array are one line of the generated code,
+ // while all odd indices are the newlines between two adjacent lines
+ // (since `REGEX_NEWLINE` captures its match).
+ // Processed fragments are accessed by calling `shiftNextLine`.
+ const remainingLines = aGeneratedCode.split(REGEX_NEWLINE)
+ let remainingLinesIndex = 0
+ const shiftNextLine = function () {
+ const lineContents = getNextLine()
+ // The last line of a file might not have a newline.
+ const newLine = getNextLine() || ''
+ return lineContents + newLine
+
+ function getNextLine() {
+ return remainingLinesIndex < remainingLines.length
+ ? remainingLines[remainingLinesIndex++]
+ : undefined
+ }
+ }
+
+ // We need to remember the position of "remainingLines"
+ let lastGeneratedLine = 1,
+ lastGeneratedColumn = 0
+
+ // The generate SourceNodes we need a code range.
+ // To extract it current and last mapping is used.
+ // Here we store the last mapping.
+ let lastMapping = null
+ let nextLine
+
+ aSourceMapConsumer.eachMapping(function (mapping) {
+ if (lastMapping !== null) {
+ // We add the code from "lastMapping" to "mapping":
+ // First check if there is a new line in between.
+ if (lastGeneratedLine < mapping.generatedLine) {
+ // Associate first line with "lastMapping"
+ addMappingWithCode(lastMapping, shiftNextLine())
+ lastGeneratedLine++
+ lastGeneratedColumn = 0
+ // The remaining code is added without mapping
+ } else {
+ // There is no new line in between.
+ // Associate the code between "lastGeneratedColumn" and
+ // "mapping.generatedColumn" with "lastMapping"
+ nextLine = remainingLines[remainingLinesIndex] || ''
+ const code = nextLine.substr(
+ 0,
+ mapping.generatedColumn - lastGeneratedColumn
+ )
+ remainingLines[remainingLinesIndex] = nextLine.substr(
+ mapping.generatedColumn - lastGeneratedColumn
+ )
+ lastGeneratedColumn = mapping.generatedColumn
+ addMappingWithCode(lastMapping, code)
+ // No more remaining code, continue
+ lastMapping = mapping
+ return
+ }
+ }
+ // We add the generated code until the first mapping
+ // to the SourceNode without any mapping.
+ // Each line is added as separate string.
+ while (lastGeneratedLine < mapping.generatedLine) {
+ node.add(shiftNextLine())
+ lastGeneratedLine++
+ }
+ if (lastGeneratedColumn < mapping.generatedColumn) {
+ nextLine = remainingLines[remainingLinesIndex] || ''
+ node.add(nextLine.substr(0, mapping.generatedColumn))
+ remainingLines[remainingLinesIndex] = nextLine.substr(
+ mapping.generatedColumn
+ )
+ lastGeneratedColumn = mapping.generatedColumn
+ }
+ lastMapping = mapping
+ }, this)
+ // We have processed all mappings.
+ if (remainingLinesIndex < remainingLines.length) {
+ if (lastMapping) {
+ // Associate the remaining code in the current line with "lastMapping"
+ addMappingWithCode(lastMapping, shiftNextLine())
+ }
+ // and add the remaining lines without any mapping
+ node.add(remainingLines.splice(remainingLinesIndex).join(''))
+ }
+
+ // Copy sourcesContent into SourceNode
+ aSourceMapConsumer.sources.forEach(function (sourceFile) {
+ const content = aSourceMapConsumer.sourceContentFor(sourceFile)
+ if (content != null) {
+ if (aRelativePath != null) {
+ sourceFile = util.join(aRelativePath, sourceFile)
+ }
+ node.setSourceContent(sourceFile, content)
+ }
+ })
+
+ return node
+
+ function addMappingWithCode(mapping, code) {
+ if (mapping === null || mapping.source === undefined) {
+ node.add(code)
+ } else {
+ const source = aRelativePath
+ ? util.join(aRelativePath, mapping.source)
+ : mapping.source
+ node.add(
+ new SourceNode(
+ mapping.originalLine,
+ mapping.originalColumn,
+ source,
+ code,
+ mapping.name
+ )
+ )
+ }
+ }
+ }
+
+ /**
+ * Add a chunk of generated JS to this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ * SourceNode, or an array where each member is one of those things.
+ */
+ add(aChunk) {
+ if (Array.isArray(aChunk)) {
+ aChunk.forEach(function (chunk) {
+ this.add(chunk)
+ }, this)
+ } else if (aChunk[isSourceNode] || typeof aChunk === 'string') {
+ if (aChunk) {
+ this.children.push(aChunk)
+ }
+ } else {
+ throw new TypeError(
+ 'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
+ aChunk
+ )
+ }
+ return this
+ }
+
+ /**
+ * Add a chunk of generated JS to the beginning of this source node.
+ *
+ * @param aChunk A string snippet of generated JS code, another instance of
+ * SourceNode, or an array where each member is one of those things.
+ */
+ prepend(aChunk) {
+ if (Array.isArray(aChunk)) {
+ for (let i = aChunk.length - 1; i >= 0; i--) {
+ this.prepend(aChunk[i])
+ }
+ } else if (aChunk[isSourceNode] || typeof aChunk === 'string') {
+ this.children.unshift(aChunk)
+ } else {
+ throw new TypeError(
+ 'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
+ aChunk
+ )
+ }
+ return this
+ }
+
+ /**
+ * Walk over the tree of JS snippets in this node and its children. The
+ * walking function is called once for each snippet of JS and is passed that
+ * snippet and the its original associated source's line/column location.
+ *
+ * @param aFn The traversal function.
+ */
+ walk(aFn) {
+ let chunk
+ for (let i = 0, len = this.children.length; i < len; i++) {
+ chunk = this.children[i]
+ if (chunk[isSourceNode]) {
+ chunk.walk(aFn)
+ } else if (chunk !== '') {
+ aFn(chunk, {
+ source: this.source,
+ line: this.line,
+ column: this.column,
+ name: this.name,
+ })
+ }
+ }
+ }
+
+ /**
+ * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
+ * each of `this.children`.
+ *
+ * @param aSep The separator.
+ */
+ join(aSep) {
+ let newChildren
+ let i
+ const len = this.children.length
+ if (len > 0) {
+ newChildren = []
+ for (i = 0; i < len - 1; i++) {
+ newChildren.push(this.children[i])
+ newChildren.push(aSep)
+ }
+ newChildren.push(this.children[i])
+ this.children = newChildren
+ }
+ return this
+ }
+
+ /**
+ * Call String.prototype.replace on the very right-most source snippet. Useful
+ * for trimming whitespace from the end of a source node, etc.
+ *
+ * @param aPattern The pattern to replace.
+ * @param aReplacement The thing to replace the pattern with.
+ */
+ replaceRight(aPattern, aReplacement) {
+ const lastChild = this.children[this.children.length - 1]
+ if (lastChild[isSourceNode]) {
+ lastChild.replaceRight(aPattern, aReplacement)
+ } else if (typeof lastChild === 'string') {
+ this.children[this.children.length - 1] = lastChild.replace(
+ aPattern,
+ aReplacement
+ )
+ } else {
+ this.children.push(''.replace(aPattern, aReplacement))
+ }
+ return this
+ }
+
+ /**
+ * Set the source content for a source file. This will be added to the SourceMapGenerator
+ * in the sourcesContent field.
+ *
+ * @param aSourceFile The filename of the source file
+ * @param aSourceContent The content of the source file
+ */
+ setSourceContent(aSourceFile, aSourceContent) {
+ this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent
+ }
+
+ /**
+ * Walk over the tree of SourceNodes. The walking function is called for each
+ * source file content and is passed the filename and source content.
+ *
+ * @param aFn The traversal function.
+ */
+ walkSourceContents(aFn) {
+ for (let i = 0, len = this.children.length; i < len; i++) {
+ if (this.children[i][isSourceNode]) {
+ this.children[i].walkSourceContents(aFn)
+ }
+ }
+
+ const sources = Object.keys(this.sourceContents)
+ for (let i = 0, len = sources.length; i < len; i++) {
+ aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]])
+ }
+ }
+
+ /**
+ * Return the string representation of this source node. Walks over the tree
+ * and concatenates all the various snippets together to one string.
+ */
+ toString() {
+ let str = ''
+ this.walk(function (chunk) {
+ str += chunk
+ })
+ return str
+ }
+
+ /**
+ * Returns the string representation of this source node along with a source
+ * map.
+ */
+ toStringWithSourceMap(aArgs) {
+ const generated = {
+ code: '',
+ line: 1,
+ column: 0,
+ }
+ const map = new SourceMapGenerator(aArgs)
+ let sourceMappingActive = false
+ let lastOriginalSource = null
+ let lastOriginalLine = null
+ let lastOriginalColumn = null
+ let lastOriginalName = null
+ this.walk(function (chunk, original) {
+ generated.code += chunk
+ if (
+ original.source !== null &&
+ original.line !== null &&
+ original.column !== null
+ ) {
+ if (
+ lastOriginalSource !== original.source ||
+ lastOriginalLine !== original.line ||
+ lastOriginalColumn !== original.column ||
+ lastOriginalName !== original.name
+ ) {
+ map.addMapping({
+ source: original.source,
+ original: {
+ line: original.line,
+ column: original.column,
+ },
+ generated: {
+ line: generated.line,
+ column: generated.column,
+ },
+ name: original.name,
+ })
+ }
+ lastOriginalSource = original.source
+ lastOriginalLine = original.line
+ lastOriginalColumn = original.column
+ lastOriginalName = original.name
+ sourceMappingActive = true
+ } else if (sourceMappingActive) {
+ map.addMapping({
+ generated: {
+ line: generated.line,
+ column: generated.column,
+ },
+ })
+ lastOriginalSource = null
+ sourceMappingActive = false
+ }
+ for (let idx = 0, length = chunk.length; idx < length; idx++) {
+ if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+ generated.line++
+ generated.column = 0
+ // Mappings end at eol
+ if (idx + 1 === length) {
+ lastOriginalSource = null
+ sourceMappingActive = false
+ } else if (sourceMappingActive) {
+ map.addMapping({
+ source: original.source,
+ original: {
+ line: original.line,
+ column: original.column,
+ },
+ generated: {
+ line: generated.line,
+ column: generated.column,
+ },
+ name: original.name,
+ })
+ }
+ } else {
+ generated.column++
+ }
+ }
+ })
+ this.walkSourceContents(function (sourceFile, sourceContent) {
+ map.setSourceContent(sourceFile, sourceContent)
+ })
+
+ return { code: generated.code, map }
+ }
+}
+
+exports.SourceNode = SourceNode
diff --git a/packages/uni-stacktracey/lib/source-map/lib/util.js b/packages/uni-stacktracey/lib/source-map/lib/util.js
new file mode 100644
index 000000000..23679a5b8
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/util.js
@@ -0,0 +1,555 @@
+/* -*- Mode: js; js-indent-level: 2; -*- */
+/*
+ * Copyright 2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * This is a helper function for getting values from parameter/options
+ * objects.
+ *
+ * @param args The object we are extracting values from
+ * @param name The name of the property we are getting.
+ * @param defaultValue An optional value to return if the property is missing
+ * from the object. If this is not specified and the property is missing, an
+ * error will be thrown.
+ */
+function getArg(aArgs, aName, aDefaultValue) {
+ if (aName in aArgs) {
+ return aArgs[aName]
+ } else if (arguments.length === 3) {
+ return aDefaultValue
+ }
+ throw new Error('"' + aName + '" is a required argument.')
+}
+exports.getArg = getArg
+
+const urlRegexp =
+ /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/
+const dataUrlRegexp = /^data:.+\,.+$/
+
+function urlParse(aUrl) {
+ const match = aUrl.match(urlRegexp)
+ if (!match) {
+ return null
+ }
+ return {
+ scheme: match[1],
+ auth: match[2],
+ host: match[3],
+ port: match[4],
+ path: match[5],
+ }
+}
+exports.urlParse = urlParse
+
+function urlGenerate(aParsedUrl) {
+ let url = ''
+ if (aParsedUrl.scheme) {
+ url += aParsedUrl.scheme + ':'
+ }
+ url += '//'
+ if (aParsedUrl.auth) {
+ url += aParsedUrl.auth + '@'
+ }
+ if (aParsedUrl.host) {
+ url += aParsedUrl.host
+ }
+ if (aParsedUrl.port) {
+ url += ':' + aParsedUrl.port
+ }
+ if (aParsedUrl.path) {
+ url += aParsedUrl.path
+ }
+ return url
+}
+exports.urlGenerate = urlGenerate
+
+const MAX_CACHED_INPUTS = 32
+
+/**
+ * Takes some function `f(input) -> result` and returns a memoized version of
+ * `f`.
+ *
+ * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
+ * memoization is a dumb-simple, linear least-recently-used cache.
+ */
+function lruMemoize(f) {
+ const cache = []
+
+ return function (input) {
+ for (let i = 0; i < cache.length; i++) {
+ if (cache[i].input === input) {
+ const temp = cache[0]
+ cache[0] = cache[i]
+ cache[i] = temp
+ return cache[0].result
+ }
+ }
+
+ const result = f(input)
+
+ cache.unshift({
+ input,
+ result,
+ })
+
+ if (cache.length > MAX_CACHED_INPUTS) {
+ cache.pop()
+ }
+
+ return result
+ }
+}
+
+/**
+ * Normalizes a path, or the path portion of a URL:
+ *
+ * - Replaces consecutive slashes with one slash.
+ * - Removes unnecessary '.' parts.
+ * - Removes unnecessary '/..' parts.
+ *
+ * Based on code in the Node.js 'path' core module.
+ *
+ * @param aPath The path or url to normalize.
+ */
+const normalize = lruMemoize(function normalize(aPath) {
+ let path = aPath
+ const url = urlParse(aPath)
+ if (url) {
+ if (!url.path) {
+ return aPath
+ }
+ path = url.path
+ }
+ const isAbsolute = exports.isAbsolute(path)
+
+ // Split the path into parts between `/` characters. This is much faster than
+ // using `.split(/\/+/g)`.
+ const parts = []
+ let start = 0
+ let i = 0
+ while (true) {
+ start = i
+ i = path.indexOf('/', start)
+ if (i === -1) {
+ parts.push(path.slice(start))
+ break
+ } else {
+ parts.push(path.slice(start, i))
+ while (i < path.length && path[i] === '/') {
+ i++
+ }
+ }
+ }
+
+ let up = 0
+ for (i = parts.length - 1; i >= 0; i--) {
+ const part = parts[i]
+ if (part === '.') {
+ parts.splice(i, 1)
+ } else if (part === '..') {
+ up++
+ } else if (up > 0) {
+ if (part === '') {
+ // The first part is blank if the path is absolute. Trying to go
+ // above the root is a no-op. Therefore we can remove all '..' parts
+ // directly after the root.
+ parts.splice(i + 1, up)
+ up = 0
+ } else {
+ parts.splice(i, 2)
+ up--
+ }
+ }
+ }
+ path = parts.join('/')
+
+ if (path === '') {
+ path = isAbsolute ? '/' : '.'
+ }
+
+ if (url) {
+ url.path = path
+ return urlGenerate(url)
+ }
+ return path
+})
+exports.normalize = normalize
+
+/**
+ * Joins two paths/URLs.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be joined with the root.
+ *
+ * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+ * scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+ * first.
+ * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+ * is updated with the result and aRoot is returned. Otherwise the result
+ * is returned.
+ * - If aPath is absolute, the result is aPath.
+ * - Otherwise the two paths are joined with a slash.
+ * - Joining for example 'http://' and 'www.example.com' is also supported.
+ */
+function join(aRoot, aPath) {
+ if (aRoot === '') {
+ aRoot = '.'
+ }
+ if (aPath === '') {
+ aPath = '.'
+ }
+ const aPathUrl = urlParse(aPath)
+ const aRootUrl = urlParse(aRoot)
+ if (aRootUrl) {
+ aRoot = aRootUrl.path || '/'
+ }
+
+ // `join(foo, '//www.example.org')`
+ if (aPathUrl && !aPathUrl.scheme) {
+ if (aRootUrl) {
+ aPathUrl.scheme = aRootUrl.scheme
+ }
+ return urlGenerate(aPathUrl)
+ }
+
+ if (aPathUrl || aPath.match(dataUrlRegexp)) {
+ return aPath
+ }
+
+ // `join('http://', 'www.example.com')`
+ if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+ aRootUrl.host = aPath
+ return urlGenerate(aRootUrl)
+ }
+
+ const joined =
+ aPath.charAt(0) === '/'
+ ? aPath
+ : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath)
+
+ if (aRootUrl) {
+ aRootUrl.path = joined
+ return urlGenerate(aRootUrl)
+ }
+ return joined
+}
+exports.join = join
+
+exports.isAbsolute = function (aPath) {
+ return aPath.charAt(0) === '/' || urlRegexp.test(aPath)
+}
+
+/**
+ * Make a path relative to a URL or another path.
+ *
+ * @param aRoot The root path or URL.
+ * @param aPath The path or URL to be made relative to aRoot.
+ */
+function relative(aRoot, aPath) {
+ if (aRoot === '') {
+ aRoot = '.'
+ }
+
+ aRoot = aRoot.replace(/\/$/, '')
+
+ // It is possible for the path to be above the root. In this case, simply
+ // checking whether the root is a prefix of the path won't work. Instead, we
+ // need to remove components from the root one by one, until either we find
+ // a prefix that fits, or we run out of components to remove.
+ let level = 0
+ while (aPath.indexOf(aRoot + '/') !== 0) {
+ const index = aRoot.lastIndexOf('/')
+ if (index < 0) {
+ return aPath
+ }
+
+ // If the only part of the root that is left is the scheme (i.e. http://,
+ // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+ // have exhausted all components, so the path is not relative to the root.
+ aRoot = aRoot.slice(0, index)
+ if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+ return aPath
+ }
+
+ ++level
+ }
+
+ // Make sure we add a "../" for each component we removed from the root.
+ return Array(level + 1).join('../') + aPath.substr(aRoot.length + 1)
+}
+exports.relative = relative
+
+const supportsNullProto = (function () {
+ const obj = Object.create(null)
+ return !('__proto__' in obj)
+})()
+
+function identity(s) {
+ return s
+}
+
+/**
+ * Because behavior goes wacky when you set `__proto__` on objects, we
+ * have to prefix all the strings in our set with an arbitrary character.
+ *
+ * See https://github.com/mozilla/source-map/pull/31 and
+ * https://github.com/mozilla/source-map/issues/30
+ *
+ * @param String aStr
+ */
+function toSetString(aStr) {
+ if (isProtoString(aStr)) {
+ return '$' + aStr
+ }
+
+ return aStr
+}
+exports.toSetString = supportsNullProto ? identity : toSetString
+
+function fromSetString(aStr) {
+ if (isProtoString(aStr)) {
+ return aStr.slice(1)
+ }
+
+ return aStr
+}
+exports.fromSetString = supportsNullProto ? identity : fromSetString
+
+function isProtoString(s) {
+ if (!s) {
+ return false
+ }
+
+ const length = s.length
+
+ if (length < 9 /* "__proto__".length */) {
+ return false
+ }
+
+ /* eslint-disable no-multi-spaces */
+ if (
+ s.charCodeAt(length - 1) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 2) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+ s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+ s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+ s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+ s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+ s.charCodeAt(length - 8) !== 95 /* '_' */ ||
+ s.charCodeAt(length - 9) !== 95 /* '_' */
+ ) {
+ return false
+ }
+ /* eslint-enable no-multi-spaces */
+
+ for (let i = length - 10; i >= 0; i--) {
+ if (s.charCodeAt(i) !== 36 /* '$' */) {
+ return false
+ }
+ }
+
+ return true
+}
+
+/**
+ * Comparator between two mappings where the original positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same original source/line/column, but different generated
+ * line and column the same. Useful when searching for a mapping with a
+ * stubbed out mapping.
+ */
+function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+ let cmp = strcmp(mappingA.source, mappingB.source)
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn
+ if (cmp !== 0 || onlyCompareOriginal) {
+ return cmp
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.generatedLine - mappingB.generatedLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ return strcmp(mappingA.name, mappingB.name)
+}
+exports.compareByOriginalPositions = compareByOriginalPositions
+
+/**
+ * Comparator between two mappings with deflated source and name indices where
+ * the generated positions are compared.
+ *
+ * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+ * mappings with the same generated line and column, but different
+ * source/name/original line and column the same. Useful when searching for a
+ * mapping with a stubbed out mapping.
+ */
+function compareByGeneratedPositionsDeflated(
+ mappingA,
+ mappingB,
+ onlyCompareGenerated
+) {
+ let cmp = mappingA.generatedLine - mappingB.generatedLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn
+ if (cmp !== 0 || onlyCompareGenerated) {
+ return cmp
+ }
+
+ cmp = strcmp(mappingA.source, mappingB.source)
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ return strcmp(mappingA.name, mappingB.name)
+}
+exports.compareByGeneratedPositionsDeflated =
+ compareByGeneratedPositionsDeflated
+
+function strcmp(aStr1, aStr2) {
+ if (aStr1 === aStr2) {
+ return 0
+ }
+
+ if (aStr1 === null) {
+ return 1 // aStr2 !== null
+ }
+
+ if (aStr2 === null) {
+ return -1 // aStr1 !== null
+ }
+
+ if (aStr1 > aStr2) {
+ return 1
+ }
+
+ return -1
+}
+
+/**
+ * Comparator between two mappings with inflated source and name strings where
+ * the generated positions are compared.
+ */
+function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+ let cmp = mappingA.generatedLine - mappingB.generatedLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.generatedColumn - mappingB.generatedColumn
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = strcmp(mappingA.source, mappingB.source)
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalLine - mappingB.originalLine
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ cmp = mappingA.originalColumn - mappingB.originalColumn
+ if (cmp !== 0) {
+ return cmp
+ }
+
+ return strcmp(mappingA.name, mappingB.name)
+}
+exports.compareByGeneratedPositionsInflated =
+ compareByGeneratedPositionsInflated
+
+/**
+ * Strip any JSON XSSI avoidance prefix from the string (as documented
+ * in the source maps specification), and then parse the string as
+ * JSON.
+ */
+function parseSourceMapInput(str) {
+ return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''))
+}
+exports.parseSourceMapInput = parseSourceMapInput
+
+/**
+ * Compute the URL of a source given the the source root, the source's
+ * URL, and the source map's URL.
+ */
+function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+ sourceURL = sourceURL || ''
+
+ if (sourceRoot) {
+ // This follows what Chrome does.
+ if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+ sourceRoot += '/'
+ }
+ // The spec says:
+ // Line 4: An optional source root, useful for relocating source
+ // files on a server or removing repeated values in the
+ // “sources” entry. This value is prepended to the individual
+ // entries in the “source” field.
+ sourceURL = sourceRoot + sourceURL
+ }
+
+ // Historically, SourceMapConsumer did not take the sourceMapURL as
+ // a parameter. This mode is still somewhat supported, which is why
+ // this code block is conditional. However, it's preferable to pass
+ // the source map URL to SourceMapConsumer, so that this function
+ // can implement the source URL resolution algorithm as outlined in
+ // the spec. This block is basically the equivalent of:
+ // new URL(sourceURL, sourceMapURL).toString()
+ // ... except it avoids using URL, which wasn't available in the
+ // older releases of node still supported by this library.
+ //
+ // The spec says:
+ // If the sources are not absolute URLs after prepending of the
+ // “sourceRoot”, the sources are resolved relative to the
+ // SourceMap (like resolving script src in a html document).
+ if (sourceMapURL) {
+ const parsed = urlParse(sourceMapURL)
+ if (!parsed) {
+ throw new Error('sourceMapURL could not be parsed')
+ }
+ if (parsed.path) {
+ // Strip the last path component, but keep the "/".
+ const index = parsed.path.lastIndexOf('/')
+ if (index >= 0) {
+ parsed.path = parsed.path.substring(0, index + 1)
+ }
+ }
+ sourceURL = join(urlGenerate(parsed), sourceURL)
+ }
+
+ return normalize(sourceURL)
+}
+exports.computeSourceURL = computeSourceURL
diff --git a/packages/uni-stacktracey/lib/source-map/lib/wasm.js b/packages/uni-stacktracey/lib/source-map/lib/wasm.js
new file mode 100644
index 000000000..8b21cf102
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/lib/wasm.js
@@ -0,0 +1,138 @@
+const readWasm = require('./read-wasm')
+
+/**
+ * Provide the JIT with a nice shape / hidden class.
+ */
+function Mapping() {
+ this.generatedLine = 0
+ this.generatedColumn = 0
+ this.lastGeneratedColumn = null
+ this.source = null
+ this.originalLine = null
+ this.originalColumn = null
+ this.name = null
+}
+
+let cachedWasm = null
+
+module.exports = function wasm() {
+ if (cachedWasm) {
+ return cachedWasm
+ }
+
+ const callbackStack = []
+
+ cachedWasm = readWasm()
+ .then((buffer) => {
+ return WebAssembly.instantiate(buffer, {
+ env: {
+ mapping_callback(
+ generatedLine,
+ generatedColumn,
+
+ hasLastGeneratedColumn,
+ lastGeneratedColumn,
+
+ hasOriginal,
+ source,
+ originalLine,
+ originalColumn,
+
+ hasName,
+ name
+ ) {
+ const mapping = new Mapping()
+ // JS uses 1-based line numbers, wasm uses 0-based.
+ mapping.generatedLine = generatedLine + 1
+ mapping.generatedColumn = generatedColumn
+
+ if (hasLastGeneratedColumn) {
+ // JS uses inclusive last generated column, wasm uses exclusive.
+ mapping.lastGeneratedColumn = lastGeneratedColumn - 1
+ }
+
+ if (hasOriginal) {
+ mapping.source = source
+ // JS uses 1-based line numbers, wasm uses 0-based.
+ mapping.originalLine = originalLine + 1
+ mapping.originalColumn = originalColumn
+
+ if (hasName) {
+ mapping.name = name
+ }
+ }
+
+ callbackStack[callbackStack.length - 1](mapping)
+ },
+
+ start_all_generated_locations_for() {
+ console.time('all_generated_locations_for')
+ },
+ end_all_generated_locations_for() {
+ console.timeEnd('all_generated_locations_for')
+ },
+
+ start_compute_column_spans() {
+ console.time('compute_column_spans')
+ },
+ end_compute_column_spans() {
+ console.timeEnd('compute_column_spans')
+ },
+
+ start_generated_location_for() {
+ console.time('generated_location_for')
+ },
+ end_generated_location_for() {
+ console.timeEnd('generated_location_for')
+ },
+
+ start_original_location_for() {
+ console.time('original_location_for')
+ },
+ end_original_location_for() {
+ console.timeEnd('original_location_for')
+ },
+
+ start_parse_mappings() {
+ console.time('parse_mappings')
+ },
+ end_parse_mappings() {
+ console.timeEnd('parse_mappings')
+ },
+
+ start_sort_by_generated_location() {
+ console.time('sort_by_generated_location')
+ },
+ end_sort_by_generated_location() {
+ console.timeEnd('sort_by_generated_location')
+ },
+
+ start_sort_by_original_location() {
+ console.time('sort_by_original_location')
+ },
+ end_sort_by_original_location() {
+ console.timeEnd('sort_by_original_location')
+ },
+ },
+ })
+ })
+ .then((Wasm) => {
+ return {
+ exports: Wasm.instance.exports,
+ withMappingCallback: (mappingCallback, f) => {
+ callbackStack.push(mappingCallback)
+ try {
+ f()
+ } finally {
+ callbackStack.pop()
+ }
+ },
+ }
+ })
+ .then(null, (e) => {
+ cachedWasm = null
+ throw e
+ })
+
+ return cachedWasm
+}
diff --git a/packages/uni-stacktracey/lib/source-map/package.json b/packages/uni-stacktracey/lib/source-map/package.json
new file mode 100644
index 000000000..1d67accb2
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/package.json
@@ -0,0 +1,91 @@
+{
+ "name": "source-map",
+ "description": "Generates and consumes source maps",
+ "version": "0.7.4",
+ "homepage": "https://github.com/mozilla/source-map",
+ "author": "Nick Fitzgerald ",
+ "contributors": [
+ "Tobias Koppers ",
+ "Duncan Beevers ",
+ "Stephen Crane ",
+ "Ryan Seddon ",
+ "Miles Elam ",
+ "Mihai Bazon ",
+ "Michael Ficarra ",
+ "Todd Wolfson ",
+ "Alexander Solovyov ",
+ "Felix Gnass ",
+ "Conrad Irwin ",
+ "usrbincc ",
+ "David Glasser ",
+ "Chase Douglas ",
+ "Evan Wallace ",
+ "Heather Arthur ",
+ "Hugh Kennedy ",
+ "David Glasser ",
+ "Simon Lydell ",
+ "Jmeas Smith ",
+ "Michael Z Goddard ",
+ "azu ",
+ "John Gozde ",
+ "Adam Kirkton ",
+ "Chris Montgomery ",
+ "J. Ryan Stinnett ",
+ "Jack Herrington ",
+ "Chris Truter ",
+ "Daniel Espeset ",
+ "Jamie Wong ",
+ "Eddy Bruël ",
+ "Hawken Rives ",
+ "Gilad Peleg ",
+ "djchie ",
+ "Gary Ye ",
+ "Nicolas Lalevée "
+ ],
+ "repository": {
+ "type": "git",
+ "url": "http://github.com/mozilla/source-map.git"
+ },
+ "main": "./source-map.js",
+ "types": "./source-map.d.ts",
+ "files": [
+ "source-map.js",
+ "source-map.d.ts",
+ "lib/",
+ "dist/source-map.js"
+ ],
+ "engines": {
+ "node": ">= 8"
+ },
+ "license": "BSD-3-Clause",
+ "scripts": {
+ "lint": "eslint *.js lib/ test/",
+ "prebuild": "npm run lint",
+ "build": "webpack --color",
+ "pretest": "npm run build",
+ "test": "node test/run-tests.js",
+ "precoverage": "npm run build",
+ "coverage": "nyc node test/run-tests.js",
+ "setup": "mkdir -p coverage && cp -n .waiting.html coverage/index.html || true",
+ "dev:live": "live-server --port=4103 --ignorePattern='(js|css|png)$' coverage",
+ "dev:watch": "watch 'npm run coverage' lib/ test/",
+ "predev": "npm run setup",
+ "dev": "npm-run-all -p --silent dev:*",
+ "clean": "rm -rf coverage .nyc_output",
+ "toc": "doctoc --title '## Table of Contents' README.md && doctoc --title '## Table of Contents' CONTRIBUTING.md"
+ },
+ "devDependencies": {
+ "doctoc": "^1.3.1",
+ "eslint": "^4.19.1",
+ "live-server": "^1.2.0",
+ "npm-run-all": "^4.1.2",
+ "nyc": "^11.7.1",
+ "watch": "^1.0.2",
+ "webpack": "^4.9.1",
+ "webpack-cli": "^3.1"
+ },
+ "nyc": {
+ "reporter": "html"
+ },
+ "typings": "source-map"
+}
diff --git a/packages/uni-stacktracey/lib/source-map/source-map.d.ts b/packages/uni-stacktracey/lib/source-map/source-map.d.ts
new file mode 100644
index 000000000..9b80fd10c
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/source-map.d.ts
@@ -0,0 +1,399 @@
+// Type definitions for source-map 0.7
+// Project: https://github.com/mozilla/source-map
+// Definitions by: Morten Houston Ludvigsen ,
+// Ron Buckton ,
+// John Vilk
+// Definitions: https://github.com/mozilla/source-map
+export type SourceMapUrl = string
+
+export interface StartOfSourceMap {
+ file?: string
+ sourceRoot?: string
+ skipValidation?: boolean
+}
+
+export interface RawSourceMap {
+ version: number
+ sources: string[]
+ names: string[]
+ sourceRoot?: string
+ sourcesContent?: string[]
+ mappings: string
+ file: string
+}
+
+export interface RawIndexMap extends StartOfSourceMap {
+ version: number
+ sections: RawSection[]
+}
+
+export interface RawSection {
+ offset: Position
+ map: RawSourceMap
+}
+
+export interface Position {
+ line: number
+ column: number
+}
+
+export interface NullablePosition {
+ line: number | null
+ column: number | null
+ lastColumn: number | null
+}
+
+export interface MappedPosition {
+ source: string
+ line: number
+ column: number
+ name?: string
+}
+
+export interface NullableMappedPosition {
+ source: string | null
+ line: number | null
+ column: number | null
+ name: string | null
+}
+
+export interface MappingItem {
+ source: string
+ generatedLine: number
+ generatedColumn: number
+ originalLine: number
+ originalColumn: number
+ name: string
+}
+
+export interface Mapping {
+ generated: Position
+ original: Position
+ source: string
+ name?: string
+}
+
+export interface CodeWithSourceMap {
+ code: string
+ map: SourceMapGenerator
+}
+
+export interface SourceMapConsumer {
+ /**
+ * Compute the last column for each generated mapping. The last column is
+ * inclusive.
+ */
+ computeColumnSpans(): void
+
+ /**
+ * Returns the original source, line, and column information for the generated
+ * source's line and column positions provided. The only argument is an object
+ * with the following properties:
+ *
+ * - line: The line number in the generated source.
+ * - column: The column number in the generated source.
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ * closest element that is smaller than or greater than the one we are
+ * searching for, respectively, if the exact element cannot be found.
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - source: The original source file, or null.
+ * - line: The line number in the original source, or null.
+ * - column: The column number in the original source, or null.
+ * - name: The original identifier, or null.
+ */
+ originalPositionFor(
+ generatedPosition: Position & { bias?: number }
+ ): NullableMappedPosition
+
+ /**
+ * Returns the generated line and column information for the original source,
+ * line, and column positions provided. The only argument is an object with
+ * the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source.
+ * - column: The column number in the original source.
+ * - bias: Either 'SourceMapConsumer.GREATEST_LOWER_BOUND' or
+ * 'SourceMapConsumer.LEAST_UPPER_BOUND'. Specifies whether to return the
+ * closest element that is smaller than or greater than the one we are
+ * searching for, respectively, if the exact element cannot be found.
+ * Defaults to 'SourceMapConsumer.GREATEST_LOWER_BOUND'.
+ *
+ * and an object is returned with the following properties:
+ *
+ * - line: The line number in the generated source, or null.
+ * - column: The column number in the generated source, or null.
+ */
+ generatedPositionFor(
+ originalPosition: MappedPosition & { bias?: number }
+ ): NullablePosition
+
+ /**
+ * Returns all generated line and column information for the original source,
+ * line, and column provided. If no column is provided, returns all mappings
+ * corresponding to a either the line we are searching for or the next
+ * closest line that has any mappings. Otherwise, returns all mappings
+ * corresponding to the given line and either the column we are searching for
+ * or the next closest column that has any offsets.
+ *
+ * The only argument is an object with the following properties:
+ *
+ * - source: The filename of the original source.
+ * - line: The line number in the original source.
+ * - column: Optional. the column number in the original source.
+ *
+ * and an array of objects is returned, each with the following properties:
+ *
+ * - line: The line number in the generated source, or null.
+ * - column: The column number in the generated source, or null.
+ */
+ allGeneratedPositionsFor(originalPosition: MappedPosition): NullablePosition[]
+
+ /**
+ * Return true if we have the source content for every source in the source
+ * map, false otherwise.
+ */
+ hasContentsOfAllSources(): boolean
+
+ /**
+ * Returns the original source content. The only argument is the url of the
+ * original source file. Returns null if no original source content is
+ * available.
+ */
+ sourceContentFor(source: string, returnNullOnMissing?: boolean): string | null
+
+ /**
+ * Iterate over each mapping between an original source/line/column and a
+ * generated line/column in this source map.
+ *
+ * @param callback
+ * The function that is called with each mapping.
+ * @param context
+ * Optional. If specified, this object will be the value of `this` every
+ * time that `aCallback` is called.
+ * @param order
+ * Either `SourceMapConsumer.GENERATED_ORDER` or
+ * `SourceMapConsumer.ORIGINAL_ORDER`. Specifies whether you want to
+ * iterate over the mappings sorted by the generated file's line/column
+ * order or the original's source/line/column order, respectively. Defaults to
+ * `SourceMapConsumer.GENERATED_ORDER`.
+ */
+ eachMapping(
+ callback: (mapping: MappingItem) => void,
+ context?: any,
+ order?: number
+ ): void
+ /**
+ * Free this source map consumer's associated wasm data that is manually-managed.
+ * Alternatively, you can use SourceMapConsumer.with to avoid needing to remember to call destroy.
+ */
+ destroy(): void
+}
+
+export interface SourceMapConsumerConstructor {
+ prototype: SourceMapConsumer
+
+ GENERATED_ORDER: number
+ ORIGINAL_ORDER: number
+ GREATEST_LOWER_BOUND: number
+ LEAST_UPPER_BOUND: number
+
+ new (
+ rawSourceMap: RawSourceMap,
+ sourceMapUrl?: SourceMapUrl
+ ): Promise
+ new (
+ rawSourceMap: RawIndexMap,
+ sourceMapUrl?: SourceMapUrl
+ ): Promise
+ new (
+ rawSourceMap: RawSourceMap | RawIndexMap | string,
+ sourceMapUrl?: SourceMapUrl
+ ): Promise
+
+ /**
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+ *
+ * @param sourceMap
+ * The source map that will be consumed.
+ */
+ fromSourceMap(
+ sourceMap: SourceMapGenerator,
+ sourceMapUrl?: SourceMapUrl
+ ): Promise
+
+ /**
+ * Construct a new `SourceMapConsumer` from `rawSourceMap` and `sourceMapUrl`
+ * (see the `SourceMapConsumer` constructor for details. Then, invoke the `async
+ * function f(SourceMapConsumer) -> T` with the newly constructed consumer, wait
+ * for `f` to complete, call `destroy` on the consumer, and return `f`'s return
+ * value.
+ *
+ * You must not use the consumer after `f` completes!
+ *
+ * By using `with`, you do not have to remember to manually call `destroy` on
+ * the consumer, since it will be called automatically once `f` completes.
+ *
+ * ```js
+ * const xSquared = await SourceMapConsumer.with(
+ * myRawSourceMap,
+ * null,
+ * async function (consumer) {
+ * // Use `consumer` inside here and don't worry about remembering
+ * // to call `destroy`.
+ *
+ * const x = await whatever(consumer);
+ * return x * x;
+ * }
+ * );
+ *
+ * // You may not use that `consumer` anymore out here; it has
+ * // been destroyed. But you can use `xSquared`.
+ * console.log(xSquared);
+ * ```
+ */
+ with(
+ rawSourceMap: RawSourceMap | RawIndexMap | string,
+ sourceMapUrl: SourceMapUrl | null | undefined,
+ callback: (
+ consumer: BasicSourceMapConsumer | IndexedSourceMapConsumer
+ ) => Promise | T
+ ): Promise
+}
+
+export const SourceMapConsumer: SourceMapConsumerConstructor
+
+export interface BasicSourceMapConsumer extends SourceMapConsumer {
+ file: string
+ sourceRoot: string
+ sources: string[]
+ sourcesContent: string[]
+}
+
+export interface BasicSourceMapConsumerConstructor {
+ prototype: BasicSourceMapConsumer
+
+ new (rawSourceMap: RawSourceMap | string): Promise
+
+ /**
+ * Create a BasicSourceMapConsumer from a SourceMapGenerator.
+ *
+ * @param sourceMap
+ * The source map that will be consumed.
+ */
+ fromSourceMap(sourceMap: SourceMapGenerator): Promise
+}
+
+export const BasicSourceMapConsumer: BasicSourceMapConsumerConstructor
+
+export interface IndexedSourceMapConsumer extends SourceMapConsumer {
+ sources: string[]
+}
+
+export interface IndexedSourceMapConsumerConstructor {
+ prototype: IndexedSourceMapConsumer
+
+ new (rawSourceMap: RawIndexMap | string): Promise
+}
+
+export const IndexedSourceMapConsumer: IndexedSourceMapConsumerConstructor
+
+export class SourceMapGenerator {
+ constructor(startOfSourceMap?: StartOfSourceMap)
+
+ /**
+ * Creates a new SourceMapGenerator based on a SourceMapConsumer
+ *
+ * @param sourceMapConsumer The SourceMap.
+ */
+ static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator
+
+ /**
+ * Add a single mapping from original source line and column to the generated
+ * source's line and column for this source map being created. The mapping
+ * object should have the following properties:
+ *
+ * - generated: An object with the generated line and column positions.
+ * - original: An object with the original line and column positions.
+ * - source: The original source file (relative to the sourceRoot).
+ * - name: An optional original token name for this mapping.
+ */
+ addMapping(mapping: Mapping): void
+
+ /**
+ * Set the source content for a source file.
+ */
+ setSourceContent(sourceFile: string, sourceContent: string): void
+
+ /**
+ * Applies the mappings of a sub-source-map for a specific source file to the
+ * source map being generated. Each mapping to the supplied source file is
+ * rewritten using the supplied source map. Note: The resolution for the
+ * resulting mappings is the minimium of this map and the supplied map.
+ *
+ * @param sourceMapConsumer The source map to be applied.
+ * @param sourceFile Optional. The filename of the source file.
+ * If omitted, SourceMapConsumer's file property will be used.
+ * @param sourceMapPath Optional. The dirname of the path to the source map
+ * to be applied. If relative, it is relative to the SourceMapConsumer.
+ * This parameter is needed when the two source maps aren't in the same
+ * directory, and the source map to be applied contains relative source
+ * paths. If so, those relative source paths need to be rewritten
+ * relative to the SourceMapGenerator.
+ */
+ applySourceMap(
+ sourceMapConsumer: SourceMapConsumer,
+ sourceFile?: string,
+ sourceMapPath?: string
+ ): void
+
+ toString(): string
+
+ toJSON(): RawSourceMap
+}
+
+export class SourceNode {
+ children: SourceNode[]
+ sourceContents: any
+ line: number
+ column: number
+ source: string
+ name: string
+
+ constructor()
+ constructor(
+ line: number | null,
+ column: number | null,
+ source: string | null,
+ chunks?: Array | SourceNode | string,
+ name?: string
+ )
+
+ static fromStringWithSourceMap(
+ code: string,
+ sourceMapConsumer: SourceMapConsumer,
+ relativePath?: string
+ ): SourceNode
+
+ add(chunk: Array | SourceNode | string): SourceNode
+
+ prepend(chunk: Array | SourceNode | string): SourceNode
+
+ setSourceContent(sourceFile: string, sourceContent: string): void
+
+ walk(fn: (chunk: string, mapping: MappedPosition) => void): void
+
+ walkSourceContents(fn: (file: string, content: string) => void): void
+
+ join(sep: string): SourceNode
+
+ replaceRight(pattern: string, replacement: string): SourceNode
+
+ toString(): string
+
+ toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap
+}
diff --git a/packages/uni-stacktracey/lib/source-map/source-map.js b/packages/uni-stacktracey/lib/source-map/source-map.js
new file mode 100644
index 000000000..b58ccc589
--- /dev/null
+++ b/packages/uni-stacktracey/lib/source-map/source-map.js
@@ -0,0 +1,10 @@
+/*
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
+ * http://opensource.org/licenses/BSD-3-Clause
+ */
+exports.SourceMapGenerator =
+ require('./lib/source-map-generator').SourceMapGenerator
+exports.SourceMapConsumer =
+ require('./lib/source-map-consumer').SourceMapConsumer
+exports.SourceNode = require('./lib/source-node').SourceNode
diff --git a/packages/uni-stacktracey/package.json b/packages/uni-stacktracey/package.json
index d03d533da..2a7158eb9 100644
--- a/packages/uni-stacktracey/package.json
+++ b/packages/uni-stacktracey/package.json
@@ -19,9 +19,6 @@
"url": "https://github.com/dcloudio/uni-app/issues"
},
"gitHead": "33e807d66e1fe47e2ee08ad9c59247e37b8884da",
- "dependencies": {
- "source-map": "^0.7.3"
- },
"devDependencies": {
"@dcloudio/types": "^2.6.12"
}
--
GitLab