From d389b23c398028713192334b2774a6f83488b068 Mon Sep 17 00:00:00 2001 From: Priyagupta108 Date: Tue, 14 Jan 2025 10:02:43 +0530 Subject: [PATCH] Upgrade-actions/cache --- .licenses/npm/@actions/cache.dep.yml | Bin 1306 -> 1306 bytes .licenses/npm/@actions/core.dep.yml | Bin 1304 -> 1304 bytes .../npm/@protobuf-ts/plugin-framework.dep.yml | Bin 0 -> 10965 bytes .licenses/npm/@protobuf-ts/plugin.dep.yml | Bin 0 -> 11026 bytes .licenses/npm/@protobuf-ts/protoc.dep.yml | Bin 0 -> 10981 bytes .../npm/@protobuf-ts/runtime-rpc.dep.yml | Bin 0 -> 11007 bytes .licenses/npm/@protobuf-ts/runtime.dep.yml | Bin 0 -> 10991 bytes .licenses/npm/camel-case.dep.yml | Bin 0 -> 1917 bytes .licenses/npm/commander.dep.yml | Bin 0 -> 1354 bytes .licenses/npm/dot-object.dep.yml | Bin 0 -> 1342 bytes .licenses/npm/fs.realpath.dep.yml | Bin 0 -> 2478 bytes .licenses/npm/glob.dep.yml | Bin 0 -> 1182 bytes .licenses/npm/inflight.dep.yml | Bin 0 -> 1021 bytes .licenses/npm/inherits.dep.yml | Bin 0 -> 1008 bytes .licenses/npm/lodash.dep.yml | Bin 0 -> 2267 bytes .licenses/npm/lower-case.dep.yml | Bin 0 -> 1873 bytes .licenses/npm/no-case.dep.yml | Bin 0 -> 1875 bytes .licenses/npm/once.dep.yml | Bin 0 -> 968 bytes .licenses/npm/pascal-case.dep.yml | Bin 0 -> 1909 bytes .licenses/npm/path-is-absolute.dep.yml | Bin 0 -> 1440 bytes .licenses/npm/path-to-regexp.dep.yml | Bin 0 -> 2111 bytes .licenses/npm/prettier.dep.yml | Bin 0 -> 315916 bytes .licenses/npm/ts-poet.dep.yml | Bin 0 -> 12215 bytes .licenses/npm/twirp-ts.dep.yml | Bin 0 -> 182 bytes .licenses/npm/typescript.dep.yml | Bin 0 -> 19832 bytes .licenses/npm/wrappy.dep.yml | Bin 0 -> 994 bytes .licenses/npm/yaml.dep.yml | Bin 0 -> 982 bytes dist/cache-save/index.js | 10313 ++++++++++++++-- dist/setup/index.js | 10243 +++++++++++++-- package-lock.json | 225 +- package.json | 2 +- 31 files changed, 18927 insertions(+), 1856 deletions(-) create mode 100644 .licenses/npm/@protobuf-ts/plugin-framework.dep.yml create mode 100644 .licenses/npm/@protobuf-ts/plugin.dep.yml create mode 100644 .licenses/npm/@protobuf-ts/protoc.dep.yml create mode 100644 .licenses/npm/@protobuf-ts/runtime-rpc.dep.yml create mode 100644 .licenses/npm/@protobuf-ts/runtime.dep.yml create mode 100644 .licenses/npm/camel-case.dep.yml create mode 100644 .licenses/npm/commander.dep.yml create mode 100644 .licenses/npm/dot-object.dep.yml create mode 100644 .licenses/npm/fs.realpath.dep.yml create mode 100644 .licenses/npm/glob.dep.yml create mode 100644 .licenses/npm/inflight.dep.yml create mode 100644 .licenses/npm/inherits.dep.yml create mode 100644 .licenses/npm/lodash.dep.yml create mode 100644 .licenses/npm/lower-case.dep.yml create mode 100644 .licenses/npm/no-case.dep.yml create mode 100644 .licenses/npm/once.dep.yml create mode 100644 .licenses/npm/pascal-case.dep.yml create mode 100644 .licenses/npm/path-is-absolute.dep.yml create mode 100644 .licenses/npm/path-to-regexp.dep.yml create mode 100644 .licenses/npm/prettier.dep.yml create mode 100644 .licenses/npm/ts-poet.dep.yml create mode 100644 .licenses/npm/twirp-ts.dep.yml create mode 100644 .licenses/npm/typescript.dep.yml create mode 100644 .licenses/npm/wrappy.dep.yml create mode 100644 .licenses/npm/yaml.dep.yml diff --git a/.licenses/npm/@actions/cache.dep.yml b/.licenses/npm/@actions/cache.dep.yml index b37997fc1bcbbf474e6ddce0a5e60b48a7e9f419..6afff44992604e8e09f0b6d6b04533a8954df0a8 100644 GIT binary patch delta 16 XcmbQmHH&M43ag2pfu6xe&5tYqCvOD7 delta 16 XcmbQmHH&M43ahc6k)Fv$&5tYqCx`^b diff --git a/.licenses/npm/@actions/core.dep.yml b/.licenses/npm/@actions/core.dep.yml index 06638c01d908037d75e2cc98a3047d7a97d0008d..09e099f71078ec77f194a04fa7006553d3ce1b14 100644 GIT binary patch delta 12 TcmbQiHG^w{8l&Mx^^Yt78HfY= delta 12 TcmbQiHG^w{8l%BR^^Yt78G{4) diff --git a/.licenses/npm/@protobuf-ts/plugin-framework.dep.yml b/.licenses/npm/@protobuf-ts/plugin-framework.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..a0214168fbdfe4aabf87863d6e650a06e0e9059b GIT binary patch literal 10965 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 B@y-AM literal 0 HcmV?d00001 diff --git a/.licenses/npm/@protobuf-ts/plugin.dep.yml b/.licenses/npm/@protobuf-ts/plugin.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..9456733da26667a059371471c2a64b8e8fe1699e GIT binary patch literal 11026 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 literal 0 HcmV?d00001 diff --git a/.licenses/npm/@protobuf-ts/protoc.dep.yml b/.licenses/npm/@protobuf-ts/protoc.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..eb2e1eb1fcf721926f0af9197632e85194af9e8f GIT binary patch literal 10981 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 NizDf^`TIZ4{tLRu|7rjL literal 0 HcmV?d00001 diff --git a/.licenses/npm/@protobuf-ts/runtime.dep.yml b/.licenses/npm/@protobuf-ts/runtime.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..44afcf79a8e0c7b018e7eb0c620225b0d8309cb4 GIT binary patch literal 10991 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 literal 0 HcmV?d00001 diff --git a/.licenses/npm/commander.dep.yml b/.licenses/npm/commander.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..7af8a2c326b39527832760dc3969dd45d56e3af7 GIT binary patch literal 1354 zcmZ8hUvHy05P#=W%v)QD47|y=b)$4miO*zzCamBkhO3u?dxS zrAP_(%?RjcU`XUS8BHYILbOi@2?J^MhSQ3q%`- zQrQ(`G$pJc5r9+Q-3or-FMxZ2)H^C5n*bi7aGaX{I_OL7;J$o-PrpAtg7_P@rZMmG zTGr!#@TYtI>rH!Ki&j-yE=&1&>fNiM)z;sDwot1de7=Hr?P@bR7?gE`ElKk-wI}xp$3@( z4CaM8Zm|XacU*>_U14PBap;g5Lqdg>!3YEEt18`$u>i5;b7#{&=>BZpV{#xELB|(wiah{%U)9 z)3GH`1L`;3xx43wqWVNKaHJYg@(@lBxkJ|M8jK_KZ3juPzKgh+OTr(0x5o@hqJF@_Bl z%;RnlIDvh_1x*iG!eM{l`@A41V~x;^vJFQjvLj3^0~BR=4&)0SK(S4-EKnu~bi#wq zG~XXNeclS#=GmIy;S)iH$x}uqI(7^|X_nAk4C`c$=%-}X8$O$_gRef+02iztxik+Pz^~d+vz-+e? z62!jueBB!si$yfbL9M7YZei*_RpX+sYO>mlEBd_rwEQ`8mox6i^AOp2802*MZ!rz> zFJ(zPIvZkw4Lu!qRN@c=V(Z(P*4>AY4W#GpMsX zs#VnMMvWG{gLd}^yNVWM%{(>Au4u=rMaEN>mkbzA{q0ut4}KA)=6sp-@#N^Sd7{rh ze)@@osc9?wu8Ts&UQL6BTr-lkbW)S5FLZ=xr`njhNhvZNH77Y8RqPGP@j_?Bf(BDN zsYj>}NRk?``D%9plr^1umy-&#!IaGdY_n@c!TS@}^_Us4Ony?Iel#iomZUCInJ`oj94_P8; ze-QhkWRS5Aoq3V-d?Ucdb}X-!U}KC43jtI@u*JUa6o0;zcOCseIkCa0Jc-pS0pd9-xp@TI7|$Q4H6j z`e=XUC5tH$yz~KWL;(sPF*txuAoY_p+$FVmQuTWp9*j7xZy{H@}+==MD?nu9=xr(-i%A zK|3R<)s_6oTnBozKMiy!>YDaN`8N%khNGlU8L6hLWh2|67$8jQU|+QO^(tpXx|Il1 zwV54tBfH{7E@rhVWowXFL!+O5n#Jsvj6U_HGz*HtK*X7V!XW<{7W6N^5#`7kW&uT` z!puGlba(F6%W>%iLhUEPn9xbq(o)Pz~W(eD|(cLmqmNF9=cQCX>{&Q4M)Or{?yztDG4zs zQ|{07(iiO@E04Nfzp6@BP%H-9uwt)mzsQ;x%W3t1I<0-1xw|-?UUi);dQvU%&cMEs zWj`1wQn;p%|=~e=+oWH~)A?kj8;yG~nPhW>TIOZNeNj?CEzN z`3+Fx9^y>ZwSF@=e6`V->#{!aF>#0FC<~T{-Dh1_$ofogM^zp%`QVRgjkU+wonD1E z6^LV>6Cf~=;*&lDSs0nNoZCt*ifl1fY(j-|NpwYv@0{mDk8=)N<+12r01^NNWFQ<^ z1H9-xn^Wxz70w8QX6(&1P?%GNF}hR*C_$AjPZzKr6z|ywF776C2)g;%bAm`%f$>ZN zUNJ3r=TI*hVkINmb8Tfm6Q*j_s1e|k9z-mJ%n#t$NLy%k+Ske)y(>z3WcZ=oXiJ6NNpzjeKCpl<}lL$y# zmWxRcv}eh0I6dv5Lp39qeA@b8Sg?zH5OJ4o6F`YClsJjQc$ETXVgvO4fa}iSc=K2& z2g&v+4IkDyt&?ae(u}@hzAe*UPYmLBlv|uSF}@(|z48s29b~_zG86cn$B!ZN-7(my sG5@^_j~VjcWAXcbp(j^tzV@{geuQ@5&W-JoDP%qy2Mz!0{Q1}HKQEf|SO5S3 literal 0 HcmV?d00001 diff --git a/.licenses/npm/glob.dep.yml b/.licenses/npm/glob.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..257b41bfee1332a1ea2ae294fd41c1db0c7fe421 GIT binary patch literal 1182 zcmY*Z+m72d6nxiL43dX7fGX;L5a3K$f;5okddgfwsAp5J?nBdJ_Zv_#RTb z-Q>kGFEeN6=#1v`c{b?YtZ?bHg8Utg*cr^~J2Ru05H-6TpUs4xX2OmCfPp)t!uAp%6JQCC`9hzK0e5rGJ2G41~;4 zObl7t%~vet|k}II@oBFCkH&y7 zWYZjPxHvrobDm*z_NhIaGcoEwKL+|}pG=~PA|^Y74dgS)PnE}4#V<$WXtYB+KzCh~ z-x|M|?5Q1xtTyU_)tq{U`?~rh)_jdOOw#%dSh+^L#13j#)mT$s3numwtSCUJnw3g$ znKV5JwL{IftR_rFFd}>yb)ow!)}8So zM|ZGhd$#2gbP%D>%gNi0DOpkFnjFeQp`w#bUF}g+k`NmlB&Q-wu?VL=l4v=@!;X{0 zIx1)7Bq~>;DkFl5tC~ekCEpfe%gdZcaFr0Ms_Ei^I-LMBuv*AiwK}MXe)dSj#8Z;B z$eLb3>vquH|2dA?j#WLCO}dDUDn_z}b(iJKCt`WL&Ana{(K4GNK%a`g H|H=LX=C5Sn literal 0 HcmV?d00001 diff --git a/.licenses/npm/inflight.dep.yml b/.licenses/npm/inflight.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..30e123e1a0ba246cd8351432b00c8c03ab883d69 GIT binary patch literal 1021 zcmY+D%Wm5+5JmU;ia}N_;77aZ!aGK$Z2~gsl2n4U=z^ALOQ`iINjWvpkIzs_ns#G} zk9+6b8F@aRC#`Ah3hMTBsn1nNuGaawYgh1j@oDiT3AY|k+rCNs&@{%~RzS)U3Uj#} zP4Ux1=)l=ugZ06q2}~|=*Ic{01mkaQ0p-wN>cRvxPO7f4y*Z<66+-V<%jLNa)o@%C zU9+scF@<0Lr9qW#edO~+^1AS=WDdR?Tw(nRGL}-VXaW%I@34YD_y(XW3rwYuP5NZq zOuPQ(Vo3Nuj{4pj7w3U}ZC_}?{ zbDn1Tn(^(ZWcx$Lu*|yyh|OrSr!w84DY<7E(@!J7hG|ZfS^(p~1<(h|HK<)g_=oMD z;`qsZMqwl5=tcMwr~^$I$!3TyX{u-F@%Dy!Qh{H~*Bt%u4y?(ZY^ee~h|<^Plx;_} z5?EPcLX~GaCfP`_hfF9`Y#>(@ix5qs9Q%mSY6g!xiik3j6Fxzunh72iSX@gInK<2M zY)g4cqgadzEhJvdvD2eq21GIytBPDl^=n2nMjwvRqU$(<*b}4~IjF>D?8)f7`F|vf NWcohvZ}a^}@&ZjXF`obc literal 0 HcmV?d00001 diff --git a/.licenses/npm/inherits.dep.yml b/.licenses/npm/inherits.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..74179e61facc04e6ea1f966d4dd44af5ca5a33f3 GIT binary patch literal 1008 zcmY*YPjA{V6u;+FJoVISA)BV1xS3$UQb?HX6m`=MCNaemi6h%-hqMpB=TOv6iU`ks zzkkopY&J`J)#*8y{-m7=K6%m38{5y}YxX7kmW0cIyZz85e(XBsE^}Bo`|7ou9i7pA zd%oPTs&6zL$1|=pwi{G1hqH!P6HefR>RaVn=xwXB-~I;i_YcX*c6w0HdY+t3qkA9C z_~uslc`^fUN7raShl1s_6f^+{`cIg{-%t1#K%O)(kwbAMNT$Wy4i{&hPXX?m2Vh>Q z27Y89n$vmILAz_$PP@+dm>7bE(d!h=50?}=+nOW3(fDWUpfx@?a~Ok$a55e(9mA_~ z7#KHIf0-nQ(GAwWWybZG-Hri{T4N@_3G2fJo}KE0Zc`YXeKDQw(V!0YMNd@G z#MOOo1ICIzuFAu^>9j_kQk}lzn2(0gb zluL+Bq?VhC!xG0>5VjRSiUJVDNhui>uxD~J8RK+KIASVliDnHTkvmFo$~w!4C% z%m;>Q1zXDV4HA+CE0}zW;uGhJ$&w0@0V|=bfIiYvg4je0AG|Fno6jtbzlusab zG-sqp(Ke^KOeZo{zEyx-d4<>IdyRb92TQUgYYg)Szm@w9k)lFX4xEa*kTJ!ISKEoN zs01QbPz#DeM3M-{IihKi!hS>1B9G1qKDlI78M{$fax7CQ>AGNRTILji6Js?YWW}+$ z#z{}06bNS`Dp$3P45)&n$Wvmp$QqAeng=?$QSB(lVQk67zWV=2@CsZn2!1#}e`@4y~bXb*LJ28FRGJToT z#&4xoRei%W^;R^(3T~#8TD81mM;xfF?aX{O8^TUY)y^i3D7iFPRJP{&`e^2pTQaKG zB{zs2FQO!mCPbFM*g5@+Z$t~#U9>pXmeP*PFFCDLFDqt&l$flBfK)1Jwb=JoX+u9> z5h$E^HixOw$JwtFAMTzRjzf}mvI5^yX+C{60RmjpeBqk67Ya@NHgBfHiYo?Dp z@Tuj6I;akoYHyj4fH?5a1!ITml7fzHN6xCS2U>Kcdb6~^Xm>ZG!O?I+6@#)BCu zJ}#Ns_0xVR!5}0sKz8@~N)K%Ny|HKvftt9P^n>$(_H=CEbwqi(DjvfuqBy5*mVS+w z(UNY$9M3laJ;ud4-4%o#S(p@0l&&aDp6ItYSq|Dqzi+cB&ne9)e%Nl}Xc*E{1DJGdmI_wueEH1a?-iW{qs8LWlyblB zN%}pQh>9PC#2#jRFAf*l5CNmvHSB^#H|(QFbXpm2SXV=N=Qbl`Bpa?$+#sdq{+hv6 z+G33SCE^{RtW*ngoBhMJn%zx5%|06E$~#x1N>6jlFTw3Ee}%&loD3%}D^Rb5#t Ar~m)} literal 0 HcmV?d00001 diff --git a/.licenses/npm/lower-case.dep.yml b/.licenses/npm/lower-case.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..e5b04b681f71a90507d8c35f3eb567ce9d4e5e74 GIT binary patch literal 1873 zcmb7FQIDfG5Pr|E7;Rs6B?8w~pCX;EByl!Y2}D3{yE@&20S9~s7};jiRQ>TCo8&fk zs?=7BL~PG|^L^i#VLqSFde-p;wDQE&ykwfsUb)gj_6vCQ-}#R-a~|-#AG(z z0&>NAeUz%xU>XkEDACtoSaC23CH>d>y<|`$=(Db$r%}lJ^>+J7KO1y_n5G%TbkFFCd~T5@%!v zVE7+q0e|5?fE>y0Xb#bo5BIoun7N~s9L`GAje+~}0UqD|{0l5CNg$3T+&8>!<*zry zt&mIdo~ur1YZ?d*4OhH4LyaaGUU_gtQ6P_iLRHN@>l5qGFrdwtAPd7pZ~bFXA_>O^ zqfLWQS{}`bDUJyhFs)@N7-B*t%dz9VVaC=xik54*x2?F#E*WkvinT6H~! z6E;JR1{Am5D=m%(qA%OAvRtmmtw4*XDi+>3q#Yot7&WS~oIU7dC64yVoy1`*TA>>c zDq-P^(O{&uo33%5)e}es8clU*h$2vf)6L<^(#2W7&@1F|u?#PrgcIJc?-hxO*Kt%m zmPV5>s*-4-tNewR#_m`ZM~SUGS(&BmD`B}e z!4h-h1m6XUF98DQ3FKJx0!InvZeT~!)fUmiC5>qQ;yJJl&0~wbNm2-5AEr579ilLW z{UO~a89^FrgpO&vNwE^ykvR9UGVTHShzrQJVHDYN4lg{QlGJjARkD9c>C-lcZ4#{s zZY~Kj43`m^%Avqj6w;js>u?u7S(Ygzh&1W6p%YVh-V(cQ>xTGSrK+zp_Xc9hspP3|C9Cv*VNi89`Tt1a4etLE zDaO8P`OwHhuz%xn8yj?@|5FS<5Szr^#?8McbbI7JTsSVr)_fS=zkQTu(-6Rq&Zp0_ FzX9I1Ttxr? literal 0 HcmV?d00001 diff --git a/.licenses/npm/no-case.dep.yml b/.licenses/npm/no-case.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..bee8a3b77f2fa8323bef525a4bd72a068c66cec8 GIT binary patch literal 1875 zcmb7F(T<}w6n)QET+P1BNCdX+K1EvXlEj%1eeN2Atqsz{oa}rs~J{+Jv2K zRjI8sQU?2;bI&=~nE8A@>sZSd(8+npG@re2rG@Mk@QeS}e>XFi-fs5oOb>0#)MWv= zVx2xp)q?1Z1O|;fa|IS%fi_BXCpZgJgYH?$H5A;OIq%>sRi$UOYqQWp zuy!c?Qno?Suy35Vh2oc>tXX&BPE=qN=RwP~;VMAVZ;02yRq-3eS=I7cBTC+BsR38RG}K)2;sPhk&hW~EBRT?k1azrR+yfhA zcYz+$M}RC06P*o`L5U)q8mu-oQfYZKXQns;Dqvd6QZVF%N|r;*JHw3ac@zz1e{ay; zU3Nv>J-9{{XN_YN9Wrv5w%yd^U_fy@#?tb5IOMV!s%fZpyAc@i*u}zKLfR3ci$S9s ztJ#BAR^n)XxwF_0MI&_WK_x7GF&M1WcF_&avwi}pKx3$m4Os+waK2wvx;mQ|W`#Pg zk!ibf#>4faBQfea4ywb}7!p=h5+ih-zw*-973<#1`q!=Ko+1M=HGC0PbZ z>U7ZEKB5HIX}pRKYZ^bo60vcD?*he_0EzPia%_5~qXe-V*pYO#MfPw>Bbq;Zj%-8o z*m7@@6hhdCX--#%C`@60NcTxbP{tamV;XN#>_m1X&VB5RYd}8X17zDUiflW_7aq__ zYPG^D**~ZBaht<7iPi)cmjo4t%ZQBa(BLWx>CS_7xCNUHRTAeZK6>al&A-E+Xhu8;Q<~XuHfgdO&Dw|&g?SVR^u@oB%aN9`x@w?zw-Ck@k zeCM8X!OP{c7))>1;D*)~&(?>|4Qu$e`o8*F#OsJF!`K&L>U-m_Ymn0b22Rt^M%)PY z)wJ<)McP8_dRv@bZ%6ZF*Tto4?GTXfLi;`m>tYGPO}@2Z4K*t%SF`|#_BF2I4~_uz z*#c7~)H7e?kEI*0zI!@H_|$#|7K~}(=L%GNzDzb+4`w(*>4xaL$0<4=X6#^n--Q$j zqJt^e1+=KNfZiRu6TT7q;yfI?Fq4?#+y%6FiZ8}nIN_ohuGzyl`OyUnFI_wXeot>V zML1cD8R2ZbeZ0bxH$$|?1&rQ3cSn0fMHBI1!92QWo28P8InLlB=FIkUIu5ZKB&ZI>`7Lx{y&mcG2ajTkAD3w{sJW&9mW6v literal 0 HcmV?d00001 diff --git a/.licenses/npm/pascal-case.dep.yml b/.licenses/npm/pascal-case.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..20cd14f631e13db23301a4ea65ac1d190449de10 GIT binary patch literal 1909 zcmb7FQIDHA5Ps)ZjJ7Yk5`k;)o+4E}HgPuA5r}|vZ&mfdfD_yTMz+~ps{8RbHpy;U zRk}MVQm{Sq&G&s{hS_Z9^{nG_7?`eDJFA%H-ZNKP$bJsL25*CRo;eK|&<~xb$F5`Q zG>1a5Uhk#qK=eie18tP(4cD-lcJ?P2um_kROT$EOtz}Rl3C9LqHVr~)xi?3qI40DuntSy&IM_YjwPgQKXb4WWt zR55B)V>$cK$y)5~KX(#`v22BIe5i$mFGqus+HShW`BqOT6<(NjqK7B~H8|a`EM1)S z3%x=fXUnwRIpPKTUXhr1?MKyPX*3C=YKa!Q%3pY8?2c8jm)Odqm08KY7FIjn9;d3n zV^+#%?sQETqL&6~yB4^nI5JbW&qumpZ3`to8;G?<@8InAMH;FdOKtE{2-dO(0KK#bcBapgC-_^dnu8CEP?gu5WyJq{TYj6@U?0loU^pt{_UD;18NCeIS2s zGm__!W{wBlY-37rpC*fVx1`Af++%K%;=4fcB|zXJg#wG7;V8k}6>LbhSR;CLPh(m< z`3`JFi^O8D(hMTlMp;1@yEw{VyUVs|PLReDp%a>{GOR>4Bq;){jC(*n;sWw@6vwul z!;5yPB(q#$k#3(d`miowoyJRooA(46M)xt9%AvqT9MO#r%V-llSe6;2h&1W6p%YVh zTob!(>qhun6f{k&q(zz(87_TPoE0zWk2EJfL>bMkIjbz)Ok%CYn1xjk2y+uMAzAyK zVJ}_65NqHL4Y+WEC5d9h!=Ot!lCZ20e(v274LsjDaXEU`OwHxuzzE79UFF{|0aeXsZIK>183h;x;}EB YFPxcUYd#F`uRcxQGz#$3^Xaqq4?M+bqyPW_ literal 0 HcmV?d00001 diff --git a/.licenses/npm/path-is-absolute.dep.yml b/.licenses/npm/path-is-absolute.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..d8fbfdd1b4347925b38a185cb28f7b5d7b0df8da GIT binary patch literal 1440 zcmZWp%Z}SP5WMRv8gudhvSzbKBM6pb(_7zOR#1f zDrr|RS403#ese4Mj=uoPM#7$zkWT%uz~DX#M{Cnx2X$#2EUJ4bl&%K}g&CUB!dn|c z8=}81oltF3neH7dem(H18SEg3PFXJ-l!ZnP@^ppEAheTp4Cg^gFlVS5FEwv)Oo+q zE95a-W_{)rZ^!S7)WqvN4jM|AWE;`8aFVluI9ure=hHW7sCGPAhnGT$7H|0w=Kfc5 zGV|C`DDrLjOgIHrz=7u<*oJQ4juaT*#qi9^U4AS9D>%u@7s$6jvKM&IvP}&12brdCwRo(EXV%_!#@QAmpPO;bcSOTd$+Kse7!?-^2kzFzQh4+ z%gW4SZ*vX=4uqF%eM||5!;v5If+CF#LT4=7a-2l>G%FLFj5(kmFo0r5($tR&c;tvm zxaSJ%{P4or)2@VFo^B{6A1N{uPEJ*bQw}#}`_iK=%?qt%{ST?<2{@wcLZ}{}v)AV`KIM>_N!^8hy NqUkQ;Tlnd7^e+Gw#qj_D literal 0 HcmV?d00001 diff --git a/.licenses/npm/path-to-regexp.dep.yml b/.licenses/npm/path-to-regexp.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..03207b9b4f892a327e59c2cdddbdf42769a616a2 GIT binary patch literal 2111 zcmbVNUu)|&6o1dBI1~mgIQHG{*h8S)xrx%4Id*W|+m&)3WLvS-%9ba|O#}PzJCc*G zE%(wfC^VMN`Tdi8Je^J_9c|eRdTN@fkyFKL_S{dNn9^K!Gx*K_?0=e=Lyt9G-%j+< zwp1NvK%RTWv<7Vsg1L4u5;9if1`LJ^ZVr=1wydW$n@t2SS*H=C<>vIDXOk&tIjEB9 z8N|_?BwI28FzngP;BWi|kT(q0Q4aCg59j!BF>zaS*&h_I8w2O%1^n{q=U?GU&_@QO zEfhPzdBcQ|zZZ6mxh21p?Xh{oRLiyX2wX$M6e|u;E7}=Wd9YKAf!smaP*pR}I-}hI zdQ1fyWML@pcvl035=A&QSZx}F(sF0^R55I*fNCvEP7xC-Sq?4h3^kT>#|6`HZqVJ? z_SkWD;fN|mg+t^WA~HB_!=9T)4hArGqj+g?Jm6g^hRSL=Z3~VOk1V#`C8Ql7x)?ON zv6?+-WyN>)KXVrQp%7d*9#q`I7lXk{Z5Q3adDc%L6=)3Ap&<%K56<_$DqWq;3$sEU z$H=r@+2d_^>xhrKc7y7W8biXWN@9eL`GJ+ju2>g4iATA&HcQ!6+O$+(N zoUidhbkd+~cLeTGoS5;nk6XH-LO{We0U|f=9GqP~Swpu&p$%RNP6hN*Io|h{{iBW* zfo;0XZ^Mj0w1rKUevKAn0cYVBpU*tFjq+7`lLJ;{VUpiLx`Z&fgFm8V;Q{$`lacKf z(#+|I)|)sYxE>|*_+}9$*KmcsNs8}6gf9UC=PBe!dW4Gz_AX&fviScHc@;lFg zEu%cK*vmA75H?|!NAsIF%wThqZPG1484H9?qGXvN6Iqia_mLUbfPBRV*sj7jwsa0J zyg?_K)e7@;bC*Tes~lEoydb!EMNnaQ6_b$;4bI~*T6?ev*WtBQnL&z3qfc8pDuvq> zvCEb>#J_nSrHQpPPm?^uM-Lrm`Ahq4v?U&dS+up`EVFbynza#Q7qTD__9kRRvhlmX zUQP*1Y=Acyz)2Gi7_5+Onqo5eLs6Jw^aheT9K;0bE!CtDz9lqiLzHVmFLC=Mt>H&Ye`7i|~_YbZ3 zQsAU6o6DAJ!<0+?eq?>CcON$R!?PVY5 LCw{N*zfJxD`N6L< literal 0 HcmV?d00001 diff --git a/.licenses/npm/prettier.dep.yml b/.licenses/npm/prettier.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..d9d358f07141d551431f69296e50a330def3aa0d GIT binary patch literal 315916 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 z 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 literal 0 HcmV?d00001 diff --git a/.licenses/npm/typescript.dep.yml b/.licenses/npm/typescript.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..01cccafdea3f3731926c2bb2aa1b219e990c6fcc GIT binary patch literal 19832 zcmbW9OK%*>mf!dK6afJPr~#7wx_5f6yy2@P7AZc=VoQ)9z=*1fs!CN>W=%dw7I!uV z-Wl+6W@R^K7URXN2JpgwVZfRO{58BV41Wv%&WT56k-U8ev$%a(k&!1(oag_Xh}7=x z?u){%+-uWp)~=pZ*}8dg>#8~{i`VAIy+7=I|J@6D^x72b)r-1at!%Y1>nL z#+uv~^VZItnU$5X>vf(@Yy%BbPi*eYslByf`qbUJyj-tb(Y#ocE4SvY*JjZ)>-zP# z-`?Hb?RA_8)xENsfBOP@uBe%4*LJdSyFcuG7su+?FLq5`w$;Sdug$yR(coe<*lX^a z7sfR1zIkn49_UNvohS0S_*}gATQtzwfxDt*SLTQBzWbd#6lMZ1emUhKuuy*sU1Mb4 z&EWccWDYKl&C%t>@$hDNc`-6?F0akcqrr~39$Z~t9{+qK!#g_bcsRPb9v=QIBl7$X~#HESe!CROj4&o2WJHX_Qc&8zGi z|5|zHsvRXe%_{UGEM(|f{@yW7X(kqB>s&vm`>xE&7I=~OnwiY_GY=#ck4(EdKtKWb3XG~zR5}}l{uzUV&o4Ua) zMe0~b(^+|^IwrKZw3@ZLuwx7M-zhaTkFZqqVebYBM96_XUn@wAxSDAM` zvoP)+PP1Crfag_KOC0lNuhtcf5Nq2uu93zMv_bq@_19BXR&M61ikI~%|Iv-F>{1q5 zmD7yvX}DwCSux356$EZ)in1|zw#ph_Mt5~NYwpCLe7r&xQzRcfO-U$e|JeI5>Y8Qq zw({|GmgO#nip%jAjN%!lZL#sJqKGyZUr?&Es$5}ilZ7qdH#ZFqSId?>X@sdGdH6Xa zu6wyCu}51|ijTI3gRJ3iYD(oSY;TVK;hy2Gji%j&bmP^8ki3ts+%&U3D+TNLP*%&Q zj(^9fSgMaRVzpuHo^Y9#KLw~c1ozYwOMY*Rm-obk9F!6gF zCok{53A;abRd$PJZk-W9)Z3B}jSKz$-h=X#?&H13m^-#Lixbqu;fQgN$I7u2AB|)s zO(a+eVI(7{z@bt^Jq>XkGpgJzE{C6qMzIJrAAUIGT6(kf;UFls?=PCOTupHCF%OAb z7AkYx0!gvJJS$j3Ww)i}--xtPf6C`$xdrDI%MJQc;vpAQZe`J44J@hDDnu3<%T}&( z`9?|RS+P`sjR{3!7lNP=SgBDtE6CC_3mU;JiP&f~iSY?DJgr{ z8+H8H+PjD&YbB8dx02bB2jyPSgOJ*aTWYV#+kt&4Lh= z)3k!mM!#W4ij)*&Nybha!t;F2Mv6*NLa40Za>8*{5?pr-(jQweh4@V+auD3GS^-lc zFqVWGOeTp(q|^97C}2(vowTH95~!}X(nuJ% zj7G6zB!{~Dm{GTP8Dkh5sMpz~E!!Hqqdr+mNb6x6<#OukY+h(2$LvHWvi4)E3-FaN z^!eolA;OxzPwstw=|OrL6g;ftdw!a>9X;(g083wJ68Bb*R#e&x*cm%42n^^nLc{jf zD%fW2{<6iSkO2Nwf<1l86_DC?zr|g11E%M=`0z%(rJotq%Ijo?79_yIuEH;ZY-s>>Y!Z03b`2Pgj8#_o^o}gJ16(S0Royk)l%KnRm1^!h z?W)|^yxHu|D#ybNM0Q(FG)i|qo%%s^XkbrJcN?c8w6wb%mvOx1{>Qroztx0Y( zifun%tqe0(5^K>K}8@AopvTndsw#3SXkgrgdg+po*B;6`Ld#>GH;u>Qze@d59fY)I|l;QXbzAd z37rD)RfjRaz*Sk-yDA=Gep0rAc>Hg4EX|<1y3LwzlrUhxf#Ia82T??o$cx*t^*6(o zB&oo(*H~8@^TcDOk`7L=s3?1>hBXzz6`R?%x6p7vK~1TgN??jbKo`~&vMBHB;6Bbv zJQQtFKZF9`nW_8?CKhF>bfG0x+f=>$cYEd<=-jns_EaY;yXoSU+H;ztm`Iux8gD)L z{!_qAd`&SPOSOb9H5x=N|4*&Hjr{`hmaP9r;*$i>P^YLQL{cl~ygFxPPMIPaMil`; zzLqq}EZzUA#hB(&xCl$W2q2SX>kRe8ZT)eq>5DGE`^;-U#KnIlf(k1cUB&lCbmv-S zpj<7O#ZM--5(@#()BYm3QUQ=Fd~||)Wi{Z^mrplAVih8koYjo4}@w3KV9C?j1BlmIOHK>vX!&b1POx6NF^Qxm$oi(gRP?D0FlIXRS2GM zW%i#XIl(f2T53vK{8phnEScO{979up7h&f~KoIR_2iB|!Jatm+q~Jk#PpZ#rE0B_h zTV_Jp9~!+H{juj+@^zn=YUNkTjY6-a)jWb*M7 z#9B>v#YiZvgO?W4rjojnyzOkYXKvVt=ul#aQuN_5N=lqoD-~aH3WC%9(M#w$vy%2@ zdG7%}D*7@sL>P~}G~5xO?Q|*@NM&)yR-dt{Ame|I?S`N$vaNx>nh&M3FN@IqX;dJ$7g7CRY`XpQPc60BrYbRD(sS_l757d zqy0&C`@NQ9p_wi8k1+cf&+0w%b3seE*4XIo<>W1+3han>$XK$-X6tPN_VYa(?==MT zUY|xu>b`JkWD+gZ^NLtKHo~wXilQ)j?!ZbtwL@6m6+|!sO@zhHLIMGZck^v8x_DhdyJ6z8^R)+M%6OYpQK;BAUUH zwLsylVFHNu`J*exE6yV-e-I+&#=|+k(moMwkg<&zH=-a}1Gp zJo-^&pnXTuNrDN|*>Tk^uts$y$blh*hbhaspnoBnXw;h~xlpQAbP+ge(vuF!r8V6= zX^vy&N|K&UQ_2yra)NM4_8bFKy6CYTYe~a4uAs&u9uiCOI1Ocr-6_eZaa)1%PaKZY zBa$MFyuhRn;5Ql;n`H2bSIjXSIm4>bqyo{1D%#WjJ3NJ!&rYYR;Na5w4Lw@A^V26a zvr;#W+W?+}kr|HY4jvwihNB(xVR&*dd`@><%y9Tn{ha4$cP`H#_EhaD8+FhX;qlcf*^HYB6tyHy4AEKh8cdR|nT% zxu4%1Tr1O8KVM&6a>%Yxz#nJjG{;eMy{1sh#9}0ZOr0;3qT10?RjxTSK>51C8DWHV2Vneuc@K^#U2(x ztJ)X8yz?%zV>+f{X~P0fG$4~;t70BLxG_v!ONvEfRGw(XAF^sWKvSY$G8b;1X8@v! z`({Tm3vE^E(r}EJ8W(gsd?bI~u%)avuQY9urKT>=#(JzKzDca0CPxEtDeqb=Lz@A? zY8ZRs2tF`wP|X)Oa$A2vwb5R zuMb^HIX0Sll4?*$UD%LjA3Wm%^ih0oSn{zy#q>d?Q=aTg+<o9@DcV3SwSw)GLpNeu*gaPba67eH z8A@0%Y)K9M4}0cdB0V{A#~4k8<%0ys`nLaJArN}oCB0B%wB*$%07?QF2U&;)FkHTTOLLnst z@n3_Flm+3uNqjO6*PLc{p;392*0#JHruTio@2aPBFEL#Ri;%_Dn?<5Q9y8>@Srui2 zpUd&7&(=@7zqVQ_Sd1vRlODd>>K%u0oD`gZr%Gj_?cvTJ=$Bz&cn5@N0-#} zA`&|pZ(e_{Kw|vQ?3(XT`||rd4?hpa?U*KXWezQO2`WFT3?1N0<_(Ava2F@b&{bJC zE1O0#b8HvcrZ>=REMv3WQg|-yHpv3uaI`4zri-@PBpPJMf{QI>K|GxHMhOaUvoQxd zacn`C+`J)J>MUh**BpGo?ci!*mvJ5!>CC}AYwP~NRVLSZ(uj1gi)mGw_pX|ALqr}# zin+Uo&310xZ8!hk4D3Ab5x6&JoM3U~p;(svY1bQ@BnBl`aVmu#bsaNj?d|poe)zhr z?Xv8z?8k4&7WJm>c9|)~ksUv{TZEE$XxaV=7H6X{Nj=LtThY^;EPja7=;xMr^EHC# zG%UROaB||l39*E>M4fN671Ps7uWdzS}aFgB1| zpTynP4|B-l$zpr#h=r5M2$?&j`Np>Sk_$K6lP@QW`pMv^adQrbAJ6?{4(Qn{JAE#Z zOxf2gOJ*2*=CaNx82kE5ZLXvOYL>|dis=UV7Zel1RU(?@=AeiU!JpZEV!9zVo-OiC zQQp?etlOrH-<0`EF4iQ2DBAJDD%Eq_;7Eze2G3%X>o`CUsG!$#FsH_;lHpc`ZKqIe ztD+|hMsJnoh!~bcU#)St!?LQ&JLEbE>IC^C5dcB6c+fr-pS1QP@p`x-v7`xPA=SAIqVO+`TQPNy3N3 zkK=YW%Um7}Q--Jm7euhQk_?>_J)&8t5EulTFB^02z&TOEjDE53jYKBV3)9$BvgCma z*UsJ8ww^?=gu`rpP_=PWfGu-F35y8p80Zcu134-?loQzIA84D|QMWy$@-%2J$g6Cx`9kg&^M&p1$w29}13A`MZin@?hIy6ea?4mrgZ4{gC! zET2ilNp&nQ%hjW?QBEg6jfqlZ;jl`g=^6xVH{SQiO^2EYZU`m8b##nqDz{9>E-rjz z>G+_9tCD*reJ+pC{}{WA0hia0xT?ez6?0?f^eLiz_a|<8I~@lGk4QV9gzaC-A_QyWt*&!QBxJ;$k^z?i_1L=6F=*;1IHfoDTQtmLi=Iv7|qhvDzGrxth5o+dV{A1$ohH zHb*(lleiLcMPw)3PVJbTaGfNHXj8Sdxv*bWc5J7SL2`aoF3l%7N(z*K1}N_>P2V(- zEq&Iy$iN#*dl&gQX5vvpw;{cuK0Oca9vNyx8+5t6YQh3l5!ujEN4{8;LMmKSv7!P?g1y zp(Ky3OymiHIa*~HqsU9a2r1~i#zG@ebp;l7L2obL1pE*z>X>3=X|BwO1~amZTr8^g z)?C{!x8$Tnq5?yP5uh}FP2^2t&B}R+=t;r;p!n4pmQ>Ws%{P%CIxvS{|BePl+PDmz zlsS#cxKDFTm!ZnO00XE}zqs2Ve!qV@`$tGMQj}YCQ*)KAIa+N}>Oba=z8U5jFNcYO zD^{@fyC3%@m*;y_m+~kGVBc|2U$$}QgNf84XLLnlFdC4L^Zs!8Wm&0s7~@3!$P}%7D{CF9OgUSMH)Jb({z><h^kdMeL zH-N$AB4Nyd*ufDvKGg*}@&vx==!k@tLYZvsen3J@?l#x}{6^B*$QE%IZ>U*ig|dvC z?ayp3_`C6mFsSbh)#4gFndP_f)%_W#?JKv68}OL`7bD2mNfX{$@ro024I)!hi$v9u zdG-O%iXlK=Ske{9xgi*YC__#5>o0iFum3%>lPvN|6e28TlhPdO%|>p3_)HQOn6-J% z{T03j;eI=)CeV9}X@D#!aJ$6ASS68TNZ{yU>o9E1L1o)7-s^Bl!f;1R-m~JU-ROM$ z)AzqiMb29+6BptpWa6Nla(9d)5UfK81%BVs*|A8fD!%@L6d%k$n%v_kac*UC1Yka3 zM)VJ&E4^(o4l6Cm5kgDZ@@?ynUJl)~7jYJLmPOcdVsl$(B;XZLIcz6r2`vgZ>IMY_ zN|Dx2>hLKSizFi*lcOm1SJ87%N?gZWff6H$GM`h+o|5u`X=!j}(Y@D85W&etsuo^8 ze5@}j&gA8?iEJxX#YPcCyJP1coe!&DMr*VNZb z>aB!Mhq*s(IzNfTi#b)C5dcpMVM}AfXCC2s!#cAIBxa}OT@)?%`5agx{v3*D4+IdA z|7D>dfZ=Uv)Id2P`cUSxS!CkQHrNJj%*H0}Pq`LL>}!(Nb>IUAky)Qq1JzSOsD~wI z{DB+;?bw`^)dM*TCKH|POtI$lkfJyxzEfCIih>nW zk#$Pn<=jR?I(0M7bFzF=#)?ly#4{;*D4XN@RN|N=&BA=SRga$PgB#p{USOPzPq0M# zRpDagm>y}2TBoHWq~{NuSMXs*oLBn(BN#K;Jri?WD-kZ?>jUsLn$T%U_~87)TxTxu zC4wy%IAqyRXFBvg%R3HeF$e%Wkp+h*Ho_As=O?qNcS#H~GwL2F1C_xIQ3m@%5KnqTAPB!q(5^lJ-X@*C$dG2W)|d&ZV0u*Ccx~ zq5hM;bJyZy;7ewPE4ykFbUFjUt`KtKmXB@3&M?5PY(0}fH4fT?V;bFwADR5F!&7IA z|NYk+`ni8&dPy_P%ypk4za)MmL@) zIVI&i%o>nP&-eq$F~JbJaIUQ%XarObn_vH`OL9DDz>Gwe9#@S&s|3@x6gsH_(z)kS z`-Ea%x7JV!-kF09)sgFT=12Rz0NuWj0A|1k7%(}-xxEML$>C{|!u=g<(4uH_!IP6- z`*eThHhyAM6W{MF%qI%F2-Egg*<|cn1HvM))Vf$RhhOFhdrk)6XDBjH9g&W@ye;4` z?Ji80;1n5_A^1hQ<4yGS^Gu*dTW`2XC-V|ThRLejnML6xY71kK?bANVA)6hfm0 zo9k#63v)4VLq{r-B>(YsCL5UBhv@$2Ci5n7N<{Li8 z>9Kj?6JwWk!@wIU^P-}{*l0nH%Qw5euN8R>4~f1#vQ+F{gt|a%q*885b)saf6`kd- z{a=5>KLZe0-C*mF^S;czA9 z_o7P71;Jjl+$uPzsx}b-Km%&18^O!*J;s(&Dbk}_IH_4_L`0Ea67Hmlk}dlQ{gUgc z=7t_hf?Lmw)Fe46$cv(@*e-Q&W?>i`g+e`Xv7QslrnARteHSGHG!Sd|_ z4Zq|D{4H)JbvtI*!P7YYX|Y|6s3)G4d_vcCdv#2}`ym$vqb&BHn>Lo6!2R7vy$9#1CqY3$uU;ndIfqdA76XDQTR5pAIf5kngs8&C; z_LSe3F_6pTOtP&=u&coY2bUnvVh+f`tbBV;CksH{Jt!JT2%gA&l@jE;&!^O7x$gMI zvg|GYWr%q8#|XXzI0}JRdHMiQ7gPJ<&-jR zbf4=wT%n32TdFX^cYWtGUZ7b0MCk9{xu*D{X5f2)@ETni@Cp|DC4$fDh-(b4`u&e_ zhV-MjOHk$tF9O|bdK~6tkBWs`BT;Gl73~k{ipN(Mn>sY@Dw2?+Um73nS3C>Vx{|ym zbXPEU0T2fALL@pSPXzA(vyjTe*MEp4(s)5vHLh4nMLk+0@(@}gzZlpdooWj6G?lhc zoujn3mdjfBX?k!ccz46+(Q$6Io;%{H{2LB3Dbj3ZB08How>EG4GcX`ISH-Y!3d=v; z5ozn7bg!e{t~VtSK`9QGtdRmVjf<=vbMU-FsT93;#E~}LtEM~Ak&)wy!{5lO3=Hz! z6KS+lg7x^7C&2*%I|S*uoDjY9aT%@|S@P+~IZ!DX+DO7C3mA-rm?9lJ-@^!U0J>wI z)Eg8nkuY_p^dD`E(j%!trTtG)l#DM7(teBQV3DGqeY2T>%af1EbPhES-9w(W(;~%H z9jD!8GY)tn1DFgdr{V6ME)rhwVGP;%f)!&}CL$MeJbBJxK!=4H<^7XRtc%TNS>oUo z_Xqky&8Ab}G)@rR$j`{Bo*zW?#h<5=@=!e8Jn$~n{&vB8aH8SzO9 zj9`qadcBQ6`r-0}oLQ&WrD1*ffXT-Z*VJ%awdQj1;JS&NdcBo)s$4yphJH%0DX$eh znBYhumt96d@`z(nNx?`bt{{by^a2+Rf2Bcn%?U>jG7>3gTwoy$#mGb-TpKQJJPXtT zE;55(W73tO_nBOSneUD`50AWfDX6YkJuNGTeC7zuPs8}u?jGZ@VyWSIv!oZ2CYO9+ zA)DQQj_nl=H|70?e+DMZ+2^kHEip2_!bht?TQNM|R4qP< zjVggqaB!fWp- zS}IG#c;KE()C=yyp~w5KK6nq>(<@UaET;MzE`Obnzyg_k}_=)r0a z7SuUu4D7Y;@aQLr>En{v5GQ2pnXUMNKym-m1D)P5?i~kRJ CgP&*s literal 0 HcmV?d00001 diff --git a/.licenses/npm/wrappy.dep.yml b/.licenses/npm/wrappy.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..2a532ec343ca5b72b9833d2a9fb53e8de07b61f1 GIT binary patch literal 994 zcmY+DOOM+i6ovQx6<1xgQXXxW*)a}DkQ|c&p3$`Gf;c2bjUNI$(@6dCz2JDH{^)#+ilWiQ5g+jlGYviQ9CnuXhdYu(Uher#LqZY#+3^?KCxuZghT z1;${nHr%qNZ_S`D2s9xKezja)Y-q;gqVC%zYAo+HuC_Lv$8FZv*?r_j~372RXYP`T-4ny zc^F1F^xnWL#s&Ny$9@cOHU=|7W1KnO;No-_%xMOL>tF22oKR5*d>GKj{>3DzXkv=f z^#OAx`>FEq?)YtK7>sscJHR7}_O0=YDW2L$09HcDfj-hwf!sw4|9E?#cpu0^L1Dv1(jw(E$OFw8 zDQ0M0&|J+>s7_9Q89{y&mMHr)^WkAD2j{sNaIC@TN} literal 0 HcmV?d00001 diff --git a/.licenses/npm/yaml.dep.yml b/.licenses/npm/yaml.dep.yml new file mode 100644 index 0000000000000000000000000000000000000000..a870f57bdeacf82ee5d6b97d73c1db4d5ea14811 GIT binary patch literal 982 zcmYk5L2u$P5QXpg6{DU5l%7^-wOThA@G3a0ZHlVZ9$YYBiNuj@=pyZp@7T0zr6^&P zdEdM@4uip<=yYo)aMkUpxELR->n1QBj_-#LMZEU-s_WY#oZD9W>jZx3iIC$Mfvn!$Z?qYXlheRFmW}#lVpBSWJ0h{Z1Hz|} zn#fu$8Ua%#tD3N-1X9<4DnYnnRKkX-MfM@+oCwr3C_~^UoLBXF%J@7h*>Y7g9P@?H z%wS1HwLlwqFF-SNSUE% zek~~uB8ntA?h#GP5;hBp7DaMS@TwGRIAAvpRszcsIGxvQPI*O>uu0t+sTzUJYut1e yl|TfOX>zkxiGa-rMGnVkiJFce?*pA=4^-eHmL!vBH|EzP85Xzi1OF|5{uXb_IU}e5 literal 0 HcmV?d00001 diff --git a/dist/cache-save/index.js b/dist/cache-save/index.js index 2b22f4a..a762d77 100644 --- a/dist/cache-save/index.js +++ b/dist/cache-save/index.js @@ -44,7 +44,10 @@ const core = __importStar(__nccwpck_require__(2186)); const path = __importStar(__nccwpck_require__(1017)); const utils = __importStar(__nccwpck_require__(1518)); const cacheHttpClient = __importStar(__nccwpck_require__(8245)); +const cacheTwirpClient = __importStar(__nccwpck_require__(2502)); +const config_1 = __nccwpck_require__(5147); const tar_1 = __nccwpck_require__(6490); +const constants_1 = __nccwpck_require__(8840); class ValidationError extends Error { constructor(message) { super(message); @@ -88,15 +91,39 @@ exports.isFeatureAvailable = isFeatureAvailable; * Restores cache from keys * * @param paths a list of file paths to restore from the cache - * @param primaryKey an explicit key for restoring the cache - * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for key + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching. + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey * @param downloadOptions cache download options * @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform * @returns string returns the key for the cache hit, otherwise returns undefined */ function restoreCache(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { return __awaiter(this, void 0, void 0, function* () { + const cacheServiceVersion = (0, config_1.getCacheServiceVersion)(); + core.debug(`Cache service version: ${cacheServiceVersion}`); checkPaths(paths); + switch (cacheServiceVersion) { + case 'v2': + return yield restoreCacheV2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive); + case 'v1': + default: + return yield restoreCacheV1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive); + } + }); +} +exports.restoreCache = restoreCache; +/** + * Restores cache using the legacy Cache Service + * + * @param paths a list of file paths to restore from the cache + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching. + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey + * @param options cache download options + * @param enableCrossOsArchive an optional boolean enabled to restore on Windows any cache created on any platform + * @returns string returns the key for the cache hit, otherwise returns undefined + */ +function restoreCacheV1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { restoreKeys = restoreKeys || []; const keys = [primaryKey, ...restoreKeys]; core.debug('Resolved Keys:'); @@ -158,7 +185,85 @@ function restoreCache(paths, primaryKey, restoreKeys, options, enableCrossOsArch return undefined; }); } -exports.restoreCache = restoreCache; +/** + * Restores cache using Cache Service v2 + * + * @param paths a list of file paths to restore from the cache + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey + * @param downloadOptions cache download options + * @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform + * @returns string returns the key for the cache hit, otherwise returns undefined + */ +function restoreCacheV2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { + // Override UploadOptions to force the use of Azure + options = Object.assign(Object.assign({}, options), { useAzureSdk: true }); + restoreKeys = restoreKeys || []; + const keys = [primaryKey, ...restoreKeys]; + core.debug('Resolved Keys:'); + core.debug(JSON.stringify(keys)); + if (keys.length > 10) { + throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`); + } + for (const key of keys) { + checkKey(key); + } + let archivePath = ''; + try { + const twirpClient = cacheTwirpClient.internalCacheTwirpClient(); + const compressionMethod = yield utils.getCompressionMethod(); + const request = { + key: primaryKey, + restoreKeys, + version: utils.getCacheVersion(paths, compressionMethod, enableCrossOsArchive) + }; + const response = yield twirpClient.GetCacheEntryDownloadURL(request); + if (!response.ok) { + core.warning(`Cache not found for keys: ${keys.join(', ')}`); + return undefined; + } + core.info(`Cache hit for: ${request.key}`); + if (options === null || options === void 0 ? void 0 : options.lookupOnly) { + core.info('Lookup only - skipping download'); + return response.matchedKey; + } + archivePath = path.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod)); + core.debug(`Archive path: ${archivePath}`); + core.debug(`Starting download of archive to: ${archivePath}`); + yield cacheHttpClient.downloadCache(response.signedDownloadUrl, archivePath, options); + const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); + core.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`); + if (core.isDebug()) { + yield (0, tar_1.listTar)(archivePath, compressionMethod); + } + yield (0, tar_1.extractTar)(archivePath, compressionMethod); + core.info('Cache restored successfully'); + return response.matchedKey; + } + catch (error) { + const typedError = error; + if (typedError.name === ValidationError.name) { + throw error; + } + else { + // Supress all non-validation cache related errors because caching should be optional + core.warning(`Failed to restore: ${error.message}`); + } + } + finally { + try { + if (archivePath) { + yield utils.unlinkFile(archivePath); + } + } + catch (error) { + core.debug(`Failed to delete archive: ${error}`); + } + } + return undefined; + }); +} /** * Saves a list of files with the specified key * @@ -169,10 +274,33 @@ exports.restoreCache = restoreCache; * @returns number returns cacheId if the cache was saved successfully and throws an error if save fails */ function saveCache(paths, key, options, enableCrossOsArchive = false) { - var _a, _b, _c, _d, _e; return __awaiter(this, void 0, void 0, function* () { + const cacheServiceVersion = (0, config_1.getCacheServiceVersion)(); + core.debug(`Cache service version: ${cacheServiceVersion}`); checkPaths(paths); checkKey(key); + switch (cacheServiceVersion) { + case 'v2': + return yield saveCacheV2(paths, key, options, enableCrossOsArchive); + case 'v1': + default: + return yield saveCacheV1(paths, key, options, enableCrossOsArchive); + } + }); +} +exports.saveCache = saveCache; +/** + * Save cache using the legacy Cache Service + * + * @param paths + * @param key + * @param options + * @param enableCrossOsArchive + * @returns + */ +function saveCacheV1(paths, key, options, enableCrossOsArchive = false) { + var _a, _b, _c, _d, _e; + return __awaiter(this, void 0, void 0, function* () { const compressionMethod = yield utils.getCompressionMethod(); let cacheId = -1; const cachePaths = yield utils.resolvePaths(paths); @@ -193,7 +321,7 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); core.debug(`File Size: ${archiveFileSize}`); // For GHES, this check will take place in ReserveCache API with enterprise file size limit - if (archiveFileSize > fileSizeLimit && !utils.isGhes()) { + if (archiveFileSize > fileSizeLimit && !(0, config_1.isGhes)()) { throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`); } core.debug('Reserving Cache'); @@ -212,7 +340,95 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message}`); } core.debug(`Saving Cache (ID: ${cacheId})`); - yield cacheHttpClient.saveCache(cacheId, archivePath, options); + yield cacheHttpClient.saveCache(cacheId, archivePath, '', options); + } + catch (error) { + const typedError = error; + if (typedError.name === ValidationError.name) { + throw error; + } + else if (typedError.name === ReserveCacheError.name) { + core.info(`Failed to save: ${typedError.message}`); + } + else { + core.warning(`Failed to save: ${typedError.message}`); + } + } + finally { + // Try to delete the archive to save space + try { + yield utils.unlinkFile(archivePath); + } + catch (error) { + core.debug(`Failed to delete archive: ${error}`); + } + } + return cacheId; + }); +} +/** + * Save cache using Cache Service v2 + * + * @param paths a list of file paths to restore from the cache + * @param key an explicit key for restoring the cache + * @param options cache upload options + * @param enableCrossOsArchive an optional boolean enabled to save cache on windows which could be restored on any platform + * @returns + */ +function saveCacheV2(paths, key, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { + // Override UploadOptions to force the use of Azure + // ...options goes first because we want to override the default values + // set in UploadOptions with these specific figures + options = Object.assign(Object.assign({}, options), { uploadChunkSize: 64 * 1024 * 1024, uploadConcurrency: 8, useAzureSdk: true }); + const compressionMethod = yield utils.getCompressionMethod(); + const twirpClient = cacheTwirpClient.internalCacheTwirpClient(); + let cacheId = -1; + const cachePaths = yield utils.resolvePaths(paths); + core.debug('Cache Paths:'); + core.debug(`${JSON.stringify(cachePaths)}`); + if (cachePaths.length === 0) { + throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`); + } + const archiveFolder = yield utils.createTempDirectory(); + const archivePath = path.join(archiveFolder, utils.getCacheFileName(compressionMethod)); + core.debug(`Archive Path: ${archivePath}`); + try { + yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod); + if (core.isDebug()) { + yield (0, tar_1.listTar)(archivePath, compressionMethod); + } + const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); + core.debug(`File Size: ${archiveFileSize}`); + // For GHES, this check will take place in ReserveCache API with enterprise file size limit + if (archiveFileSize > constants_1.CacheFileSizeLimit && !(0, config_1.isGhes)()) { + throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`); + } + // Set the archive size in the options, will be used to display the upload progress + options.archiveSizeBytes = archiveFileSize; + core.debug('Reserving Cache'); + const version = utils.getCacheVersion(paths, compressionMethod, enableCrossOsArchive); + const request = { + key, + version + }; + const response = yield twirpClient.CreateCacheEntry(request); + if (!response.ok) { + throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache.`); + } + core.debug(`Attempting to upload cache located at: ${archivePath}`); + yield cacheHttpClient.saveCache(cacheId, archivePath, response.signedUploadUrl, options); + const finalizeRequest = { + key, + version, + sizeBytes: `${archiveFileSize}` + }; + const finalizeResponse = yield twirpClient.FinalizeCacheEntryUpload(finalizeRequest); + core.debug(`FinalizeCacheEntryUploadResponse: ${finalizeResponse.ok}`); + if (!finalizeResponse.ok) { + throw new Error(`Unable to finalize cache with key ${key}, another job may be finalizing this cache.`); + } + cacheId = parseInt(finalizeResponse.entryId); } catch (error) { const typedError = error; @@ -238,11 +454,1753 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { return cacheId; }); } -exports.saveCache = saveCache; //# sourceMappingURL=cache.js.map /***/ }), +/***/ 4469: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Timestamp = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const runtime_6 = __nccwpck_require__(4061); +const runtime_7 = __nccwpck_require__(4061); +// @generated message type with reflection information, may provide speed optimized methods +class Timestamp$Type extends runtime_7.MessageType { + constructor() { + super("google.protobuf.Timestamp", [ + { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ } + ]); + } + /** + * Creates a new `Timestamp` for the current time. + */ + now() { + const msg = this.create(); + const ms = Date.now(); + msg.seconds = runtime_6.PbLong.from(Math.floor(ms / 1000)).toString(); + msg.nanos = (ms % 1000) * 1000000; + return msg; + } + /** + * Converts a `Timestamp` to a JavaScript Date. + */ + toDate(message) { + return new Date(runtime_6.PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000)); + } + /** + * Converts a JavaScript Date to a `Timestamp`. + */ + fromDate(date) { + const msg = this.create(); + const ms = date.getTime(); + msg.seconds = runtime_6.PbLong.from(Math.floor(ms / 1000)).toString(); + msg.nanos = (ms % 1000) * 1000000; + return msg; + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonWrite(message, options) { + let ms = runtime_6.PbLong.from(message.seconds).toNumber() * 1000; + if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) + throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."); + if (message.nanos < 0) + throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative."); + let z = "Z"; + if (message.nanos > 0) { + let nanosStr = (message.nanos + 1000000000).toString().substring(1); + if (nanosStr.substring(3) === "000000") + z = "." + nanosStr.substring(0, 3) + "Z"; + else if (nanosStr.substring(6) === "000") + z = "." + nanosStr.substring(0, 6) + "Z"; + else + z = "." + nanosStr + "Z"; + } + return new Date(ms).toISOString().replace(".000Z", z); + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonRead(json, options, target) { + if (typeof json !== "string") + throw new Error("Unable to parse Timestamp from JSON " + (0, runtime_5.typeofJsonValue)(json) + "."); + let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/); + if (!matches) + throw new Error("Unable to parse Timestamp from JSON. Invalid format."); + let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z")); + if (Number.isNaN(ms)) + throw new Error("Unable to parse Timestamp from JSON. Invalid value."); + if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) + throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."); + if (!target) + target = this.create(); + target.seconds = runtime_6.PbLong.from(ms / 1000).toString(); + target.nanos = 0; + if (matches[7]) + target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000); + return target; + } + create(value) { + const message = { seconds: "0", nanos: 0 }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 seconds */ 1: + message.seconds = reader.int64().toString(); + break; + case /* int32 nanos */ 2: + message.nanos = reader.int32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int64 seconds = 1; */ + if (message.seconds !== "0") + writer.tag(1, runtime_1.WireType.Varint).int64(message.seconds); + /* int32 nanos = 2; */ + if (message.nanos !== 0) + writer.tag(2, runtime_1.WireType.Varint).int32(message.nanos); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.Timestamp + */ +exports.Timestamp = new Timestamp$Type(); +//# sourceMappingURL=timestamp.js.map + +/***/ }), + +/***/ 4388: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheService = exports.LookupCacheEntryResponse = exports.LookupCacheEntryRequest = exports.ListCacheEntriesResponse = exports.ListCacheEntriesRequest = exports.DeleteCacheEntryResponse = exports.DeleteCacheEntryRequest = exports.GetCacheEntryDownloadURLResponse = exports.GetCacheEntryDownloadURLRequest = exports.FinalizeCacheEntryUploadResponse = exports.FinalizeCacheEntryUploadRequest = exports.CreateCacheEntryResponse = exports.CreateCacheEntryRequest = void 0; +// @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies +// @generated from protobuf file "results/api/v1/cache.proto" (package "github.actions.results.api.v1", syntax proto3) +// tslint:disable +const runtime_rpc_1 = __nccwpck_require__(12); +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const cacheentry_1 = __nccwpck_require__(3639); +const cachemetadata_1 = __nccwpck_require__(7988); +// @generated message type with reflection information, may provide speed optimized methods +class CreateCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.CreateCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* string version */ 3: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* string version = 3; */ + if (message.version !== "") + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryRequest + */ +exports.CreateCacheEntryRequest = new CreateCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class CreateCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.CreateCacheEntryResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "signed_upload_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { ok: false, signedUploadUrl: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* string signed_upload_url */ 2: + message.signedUploadUrl = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* string signed_upload_url = 2; */ + if (message.signedUploadUrl !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.signedUploadUrl); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryResponse + */ +exports.CreateCacheEntryResponse = new CreateCacheEntryResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FinalizeCacheEntryUploadRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.FinalizeCacheEntryUploadRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "size_bytes", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", sizeBytes: "0", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* int64 size_bytes */ 3: + message.sizeBytes = reader.int64().toString(); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* int64 size_bytes = 3; */ + if (message.sizeBytes !== "0") + writer.tag(3, runtime_1.WireType.Varint).int64(message.sizeBytes); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadRequest + */ +exports.FinalizeCacheEntryUploadRequest = new FinalizeCacheEntryUploadRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FinalizeCacheEntryUploadResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.FinalizeCacheEntryUploadResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { ok: false, entryId: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* int64 entry_id */ 2: + message.entryId = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* int64 entry_id = 2; */ + if (message.entryId !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.entryId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadResponse + */ +exports.FinalizeCacheEntryUploadResponse = new FinalizeCacheEntryUploadResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetCacheEntryDownloadURLRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.GetCacheEntryDownloadURLRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [], version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLRequest + */ +exports.GetCacheEntryDownloadURLRequest = new GetCacheEntryDownloadURLRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetCacheEntryDownloadURLResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.GetCacheEntryDownloadURLResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "signed_download_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "matched_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { ok: false, signedDownloadUrl: "", matchedKey: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* string signed_download_url */ 2: + message.signedDownloadUrl = reader.string(); + break; + case /* string matched_key */ 3: + message.matchedKey = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* string signed_download_url = 2; */ + if (message.signedDownloadUrl !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.signedDownloadUrl); + /* string matched_key = 3; */ + if (message.matchedKey !== "") + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.matchedKey); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLResponse + */ +exports.GetCacheEntryDownloadURLResponse = new GetCacheEntryDownloadURLResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DeleteCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.DeleteCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.DeleteCacheEntryRequest + */ +exports.DeleteCacheEntryRequest = new DeleteCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DeleteCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.DeleteCacheEntryResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { ok: false, entryId: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* int64 entry_id */ 2: + message.entryId = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* int64 entry_id = 2; */ + if (message.entryId !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.entryId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.DeleteCacheEntryResponse + */ +exports.DeleteCacheEntryResponse = new DeleteCacheEntryResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ListCacheEntriesRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.ListCacheEntriesRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.ListCacheEntriesRequest + */ +exports.ListCacheEntriesRequest = new ListCacheEntriesRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ListCacheEntriesResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.ListCacheEntriesResponse", [ + { no: 1, name: "entries", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => cacheentry_1.CacheEntry } + ]); + } + create(value) { + const message = { entries: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated github.actions.results.entities.v1.CacheEntry entries */ 1: + message.entries.push(cacheentry_1.CacheEntry.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated github.actions.results.entities.v1.CacheEntry entries = 1; */ + for (let i = 0; i < message.entries.length; i++) + cacheentry_1.CacheEntry.internalBinaryWrite(message.entries[i], writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.ListCacheEntriesResponse + */ +exports.ListCacheEntriesResponse = new ListCacheEntriesResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class LookupCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.LookupCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [], version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.LookupCacheEntryRequest + */ +exports.LookupCacheEntryRequest = new LookupCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class LookupCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.LookupCacheEntryResponse", [ + { no: 1, name: "exists", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry", kind: "message", T: () => cacheentry_1.CacheEntry } + ]); + } + create(value) { + const message = { exists: false }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool exists */ 1: + message.exists = reader.bool(); + break; + case /* github.actions.results.entities.v1.CacheEntry entry */ 2: + message.entry = cacheentry_1.CacheEntry.internalBinaryRead(reader, reader.uint32(), options, message.entry); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool exists = 1; */ + if (message.exists !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.exists); + /* github.actions.results.entities.v1.CacheEntry entry = 2; */ + if (message.entry) + cacheentry_1.CacheEntry.internalBinaryWrite(message.entry, writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.LookupCacheEntryResponse + */ +exports.LookupCacheEntryResponse = new LookupCacheEntryResponse$Type(); +/** + * @generated ServiceType for protobuf service github.actions.results.api.v1.CacheService + */ +exports.CacheService = new runtime_rpc_1.ServiceType("github.actions.results.api.v1.CacheService", [ + { name: "CreateCacheEntry", options: {}, I: exports.CreateCacheEntryRequest, O: exports.CreateCacheEntryResponse }, + { name: "FinalizeCacheEntryUpload", options: {}, I: exports.FinalizeCacheEntryUploadRequest, O: exports.FinalizeCacheEntryUploadResponse }, + { name: "GetCacheEntryDownloadURL", options: {}, I: exports.GetCacheEntryDownloadURLRequest, O: exports.GetCacheEntryDownloadURLResponse }, + { name: "DeleteCacheEntry", options: {}, I: exports.DeleteCacheEntryRequest, O: exports.DeleteCacheEntryResponse }, + { name: "ListCacheEntries", options: {}, I: exports.ListCacheEntriesRequest, O: exports.ListCacheEntriesResponse }, + { name: "LookupCacheEntry", options: {}, I: exports.LookupCacheEntryRequest, O: exports.LookupCacheEntryResponse } +]); +//# sourceMappingURL=cache.js.map + +/***/ }), + +/***/ 267: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createCacheServiceServer = exports.CacheServiceMethodList = exports.CacheServiceMethod = exports.CacheServiceClientProtobuf = exports.CacheServiceClientJSON = void 0; +const twirp_ts_1 = __nccwpck_require__(6465); +const cache_1 = __nccwpck_require__(4388); +class CacheServiceClientJSON { + constructor(rpc) { + this.rpc = rpc; + this.CreateCacheEntry.bind(this); + this.FinalizeCacheEntryUpload.bind(this); + this.GetCacheEntryDownloadURL.bind(this); + this.DeleteCacheEntry.bind(this); + this.ListCacheEntries.bind(this); + this.LookupCacheEntry.bind(this); + } + CreateCacheEntry(request) { + const data = cache_1.CreateCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "CreateCacheEntry", "application/json", data); + return promise.then((data) => cache_1.CreateCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + FinalizeCacheEntryUpload(request) { + const data = cache_1.FinalizeCacheEntryUploadRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "FinalizeCacheEntryUpload", "application/json", data); + return promise.then((data) => cache_1.FinalizeCacheEntryUploadResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + GetCacheEntryDownloadURL(request) { + const data = cache_1.GetCacheEntryDownloadURLRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "GetCacheEntryDownloadURL", "application/json", data); + return promise.then((data) => cache_1.GetCacheEntryDownloadURLResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + DeleteCacheEntry(request) { + const data = cache_1.DeleteCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "DeleteCacheEntry", "application/json", data); + return promise.then((data) => cache_1.DeleteCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + ListCacheEntries(request) { + const data = cache_1.ListCacheEntriesRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "ListCacheEntries", "application/json", data); + return promise.then((data) => cache_1.ListCacheEntriesResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + LookupCacheEntry(request) { + const data = cache_1.LookupCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "LookupCacheEntry", "application/json", data); + return promise.then((data) => cache_1.LookupCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } +} +exports.CacheServiceClientJSON = CacheServiceClientJSON; +class CacheServiceClientProtobuf { + constructor(rpc) { + this.rpc = rpc; + this.CreateCacheEntry.bind(this); + this.FinalizeCacheEntryUpload.bind(this); + this.GetCacheEntryDownloadURL.bind(this); + this.DeleteCacheEntry.bind(this); + this.ListCacheEntries.bind(this); + this.LookupCacheEntry.bind(this); + } + CreateCacheEntry(request) { + const data = cache_1.CreateCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "CreateCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.CreateCacheEntryResponse.fromBinary(data)); + } + FinalizeCacheEntryUpload(request) { + const data = cache_1.FinalizeCacheEntryUploadRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "FinalizeCacheEntryUpload", "application/protobuf", data); + return promise.then((data) => cache_1.FinalizeCacheEntryUploadResponse.fromBinary(data)); + } + GetCacheEntryDownloadURL(request) { + const data = cache_1.GetCacheEntryDownloadURLRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "GetCacheEntryDownloadURL", "application/protobuf", data); + return promise.then((data) => cache_1.GetCacheEntryDownloadURLResponse.fromBinary(data)); + } + DeleteCacheEntry(request) { + const data = cache_1.DeleteCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "DeleteCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.DeleteCacheEntryResponse.fromBinary(data)); + } + ListCacheEntries(request) { + const data = cache_1.ListCacheEntriesRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "ListCacheEntries", "application/protobuf", data); + return promise.then((data) => cache_1.ListCacheEntriesResponse.fromBinary(data)); + } + LookupCacheEntry(request) { + const data = cache_1.LookupCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "LookupCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.LookupCacheEntryResponse.fromBinary(data)); + } +} +exports.CacheServiceClientProtobuf = CacheServiceClientProtobuf; +var CacheServiceMethod; +(function (CacheServiceMethod) { + CacheServiceMethod["CreateCacheEntry"] = "CreateCacheEntry"; + CacheServiceMethod["FinalizeCacheEntryUpload"] = "FinalizeCacheEntryUpload"; + CacheServiceMethod["GetCacheEntryDownloadURL"] = "GetCacheEntryDownloadURL"; + CacheServiceMethod["DeleteCacheEntry"] = "DeleteCacheEntry"; + CacheServiceMethod["ListCacheEntries"] = "ListCacheEntries"; + CacheServiceMethod["LookupCacheEntry"] = "LookupCacheEntry"; +})(CacheServiceMethod || (exports.CacheServiceMethod = CacheServiceMethod = {})); +exports.CacheServiceMethodList = [ + CacheServiceMethod.CreateCacheEntry, + CacheServiceMethod.FinalizeCacheEntryUpload, + CacheServiceMethod.GetCacheEntryDownloadURL, + CacheServiceMethod.DeleteCacheEntry, + CacheServiceMethod.ListCacheEntries, + CacheServiceMethod.LookupCacheEntry, +]; +function createCacheServiceServer(service) { + return new twirp_ts_1.TwirpServer({ + service, + packageName: "github.actions.results.api.v1", + serviceName: "CacheService", + methodList: exports.CacheServiceMethodList, + matchRoute: matchCacheServiceRoute, + }); +} +exports.createCacheServiceServer = createCacheServiceServer; +function matchCacheServiceRoute(method, events) { + switch (method) { + case "CreateCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "CreateCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceCreateCacheEntryRequest(ctx, service, data, interceptors); + }); + case "FinalizeCacheEntryUpload": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "FinalizeCacheEntryUpload" }); + yield events.onMatch(ctx); + return handleCacheServiceFinalizeCacheEntryUploadRequest(ctx, service, data, interceptors); + }); + case "GetCacheEntryDownloadURL": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "GetCacheEntryDownloadURL" }); + yield events.onMatch(ctx); + return handleCacheServiceGetCacheEntryDownloadURLRequest(ctx, service, data, interceptors); + }); + case "DeleteCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "DeleteCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceDeleteCacheEntryRequest(ctx, service, data, interceptors); + }); + case "ListCacheEntries": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "ListCacheEntries" }); + yield events.onMatch(ctx); + return handleCacheServiceListCacheEntriesRequest(ctx, service, data, interceptors); + }); + case "LookupCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "LookupCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceLookupCacheEntryRequest(ctx, service, data, interceptors); + }); + default: + events.onNotFound(); + const msg = `no handler found`; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceCreateCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceCreateCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceCreateCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceFinalizeCacheEntryUploadRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceFinalizeCacheEntryUploadJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceFinalizeCacheEntryUploadProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceGetCacheEntryDownloadURLRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceGetCacheEntryDownloadURLJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceGetCacheEntryDownloadURLProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceDeleteCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceDeleteCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceDeleteCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceListCacheEntriesRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceListCacheEntriesJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceListCacheEntriesProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceLookupCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceLookupCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceLookupCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceCreateCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.CreateCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.CreateCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.CreateCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.CreateCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceFinalizeCacheEntryUploadJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.FinalizeCacheEntryUploadRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.FinalizeCacheEntryUpload(ctx, inputReq); + }); + } + else { + response = yield service.FinalizeCacheEntryUpload(ctx, request); + } + return JSON.stringify(cache_1.FinalizeCacheEntryUploadResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceGetCacheEntryDownloadURLJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.GetCacheEntryDownloadURLRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.GetCacheEntryDownloadURL(ctx, inputReq); + }); + } + else { + response = yield service.GetCacheEntryDownloadURL(ctx, request); + } + return JSON.stringify(cache_1.GetCacheEntryDownloadURLResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceDeleteCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.DeleteCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.DeleteCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.DeleteCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.DeleteCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceListCacheEntriesJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.ListCacheEntriesRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.ListCacheEntries(ctx, inputReq); + }); + } + else { + response = yield service.ListCacheEntries(ctx, request); + } + return JSON.stringify(cache_1.ListCacheEntriesResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceLookupCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.LookupCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.LookupCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.LookupCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.LookupCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceCreateCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.CreateCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.CreateCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.CreateCacheEntry(ctx, request); + } + return Buffer.from(cache_1.CreateCacheEntryResponse.toBinary(response)); + }); +} +function handleCacheServiceFinalizeCacheEntryUploadProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.FinalizeCacheEntryUploadRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.FinalizeCacheEntryUpload(ctx, inputReq); + }); + } + else { + response = yield service.FinalizeCacheEntryUpload(ctx, request); + } + return Buffer.from(cache_1.FinalizeCacheEntryUploadResponse.toBinary(response)); + }); +} +function handleCacheServiceGetCacheEntryDownloadURLProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.GetCacheEntryDownloadURLRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.GetCacheEntryDownloadURL(ctx, inputReq); + }); + } + else { + response = yield service.GetCacheEntryDownloadURL(ctx, request); + } + return Buffer.from(cache_1.GetCacheEntryDownloadURLResponse.toBinary(response)); + }); +} +function handleCacheServiceDeleteCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.DeleteCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.DeleteCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.DeleteCacheEntry(ctx, request); + } + return Buffer.from(cache_1.DeleteCacheEntryResponse.toBinary(response)); + }); +} +function handleCacheServiceListCacheEntriesProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.ListCacheEntriesRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.ListCacheEntries(ctx, inputReq); + }); + } + else { + response = yield service.ListCacheEntries(ctx, request); + } + return Buffer.from(cache_1.ListCacheEntriesResponse.toBinary(response)); + }); +} +function handleCacheServiceLookupCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.LookupCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.LookupCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.LookupCacheEntry(ctx, request); + } + return Buffer.from(cache_1.LookupCacheEntryResponse.toBinary(response)); + }); +} +//# sourceMappingURL=cache.twirp.js.map + +/***/ }), + +/***/ 3639: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheEntry = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const timestamp_1 = __nccwpck_require__(4469); +// @generated message type with reflection information, may provide speed optimized methods +class CacheEntry$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheEntry", [ + { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "size_bytes", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 4, name: "scope", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 6, name: "created_at", kind: "message", T: () => timestamp_1.Timestamp }, + { no: 7, name: "last_accessed_at", kind: "message", T: () => timestamp_1.Timestamp }, + { no: 8, name: "expires_at", kind: "message", T: () => timestamp_1.Timestamp } + ]); + } + create(value) { + const message = { key: "", hash: "", sizeBytes: "0", scope: "", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string key */ 1: + message.key = reader.string(); + break; + case /* string hash */ 2: + message.hash = reader.string(); + break; + case /* int64 size_bytes */ 3: + message.sizeBytes = reader.int64().toString(); + break; + case /* string scope */ 4: + message.scope = reader.string(); + break; + case /* string version */ 5: + message.version = reader.string(); + break; + case /* google.protobuf.Timestamp created_at */ 6: + message.createdAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt); + break; + case /* google.protobuf.Timestamp last_accessed_at */ 7: + message.lastAccessedAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.lastAccessedAt); + break; + case /* google.protobuf.Timestamp expires_at */ 8: + message.expiresAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.expiresAt); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* string key = 1; */ + if (message.key !== "") + writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.key); + /* string hash = 2; */ + if (message.hash !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.hash); + /* int64 size_bytes = 3; */ + if (message.sizeBytes !== "0") + writer.tag(3, runtime_1.WireType.Varint).int64(message.sizeBytes); + /* string scope = 4; */ + if (message.scope !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.scope); + /* string version = 5; */ + if (message.version !== "") + writer.tag(5, runtime_1.WireType.LengthDelimited).string(message.version); + /* google.protobuf.Timestamp created_at = 6; */ + if (message.createdAt) + timestamp_1.Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* google.protobuf.Timestamp last_accessed_at = 7; */ + if (message.lastAccessedAt) + timestamp_1.Timestamp.internalBinaryWrite(message.lastAccessedAt, writer.tag(7, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* google.protobuf.Timestamp expires_at = 8; */ + if (message.expiresAt) + timestamp_1.Timestamp.internalBinaryWrite(message.expiresAt, writer.tag(8, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheEntry + */ +exports.CacheEntry = new CacheEntry$Type(); +//# sourceMappingURL=cacheentry.js.map + +/***/ }), + +/***/ 7988: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheMetadata = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const cachescope_1 = __nccwpck_require__(3749); +// @generated message type with reflection information, may provide speed optimized methods +class CacheMetadata$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheMetadata", [ + { no: 1, name: "repository_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 2, name: "scope", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => cachescope_1.CacheScope } + ]); + } + create(value) { + const message = { repositoryId: "0", scope: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 repository_id */ 1: + message.repositoryId = reader.int64().toString(); + break; + case /* repeated github.actions.results.entities.v1.CacheScope scope */ 2: + message.scope.push(cachescope_1.CacheScope.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int64 repository_id = 1; */ + if (message.repositoryId !== "0") + writer.tag(1, runtime_1.WireType.Varint).int64(message.repositoryId); + /* repeated github.actions.results.entities.v1.CacheScope scope = 2; */ + for (let i = 0; i < message.scope.length; i++) + cachescope_1.CacheScope.internalBinaryWrite(message.scope[i], writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheMetadata + */ +exports.CacheMetadata = new CacheMetadata$Type(); +//# sourceMappingURL=cachemetadata.js.map + +/***/ }), + +/***/ 3749: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheScope = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +// @generated message type with reflection information, may provide speed optimized methods +class CacheScope$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheScope", [ + { no: 1, name: "scope", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "permission", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { scope: "", permission: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string scope */ 1: + message.scope = reader.string(); + break; + case /* int64 permission */ 2: + message.permission = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* string scope = 1; */ + if (message.scope !== "") + writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.scope); + /* int64 permission = 2; */ + if (message.permission !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.permission); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheScope + */ +exports.CacheScope = new CacheScope$Type(); +//# sourceMappingURL=cachescope.js.map + +/***/ }), + /***/ 8245: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -281,20 +2239,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.saveCache = exports.reserveCache = exports.downloadCache = exports.getCacheEntry = exports.getCacheVersion = void 0; +exports.saveCache = exports.reserveCache = exports.downloadCache = exports.getCacheEntry = void 0; const core = __importStar(__nccwpck_require__(2186)); const http_client_1 = __nccwpck_require__(6255); const auth_1 = __nccwpck_require__(5526); -const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const url_1 = __nccwpck_require__(7310); const utils = __importStar(__nccwpck_require__(1518)); +const uploadUtils_1 = __nccwpck_require__(1786); const downloadUtils_1 = __nccwpck_require__(5500); const options_1 = __nccwpck_require__(6215); const requestUtils_1 = __nccwpck_require__(3981); -const versionSalt = '1.0'; +const config_1 = __nccwpck_require__(5147); +const user_agent_1 = __nccwpck_require__(580); function getCacheApiUrl(resource) { - const baseUrl = process.env['ACTIONS_CACHE_URL'] || ''; + const baseUrl = (0, config_1.getCacheServiceURL)(); if (!baseUrl) { throw new Error('Cache Service Url not found, unable to restore cache.'); } @@ -316,29 +2275,12 @@ function getRequestOptions() { function createHttpClient() { const token = process.env['ACTIONS_RUNTIME_TOKEN'] || ''; const bearerCredentialHandler = new auth_1.BearerCredentialHandler(token); - return new http_client_1.HttpClient('actions/cache', [bearerCredentialHandler], getRequestOptions()); + return new http_client_1.HttpClient((0, user_agent_1.getUserAgentString)(), [bearerCredentialHandler], getRequestOptions()); } -function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) { - // don't pass changes upstream - const components = paths.slice(); - // Add compression method to cache version to restore - // compressed cache as per compression method - if (compressionMethod) { - components.push(compressionMethod); - } - // Only check for windows platforms if enableCrossOsArchive is false - if (process.platform === 'win32' && !enableCrossOsArchive) { - components.push('windows-only'); - } - // Add salt to cache version to support breaking changes in cache entry - components.push(versionSalt); - return crypto.createHash('sha256').update(components.join('|')).digest('hex'); -} -exports.getCacheVersion = getCacheVersion; function getCacheEntry(keys, paths, options) { return __awaiter(this, void 0, void 0, function* () { const httpClient = createHttpClient(); - const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); + const version = utils.getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); const resource = `cache?keys=${encodeURIComponent(keys.join(','))}&version=${version}`; const response = yield (0, requestUtils_1.retryTypedResponse)('getCacheEntry', () => __awaiter(this, void 0, void 0, function* () { return httpClient.getJson(getCacheApiUrl(resource)); })); // Cache not found @@ -409,7 +2351,7 @@ exports.downloadCache = downloadCache; function reserveCache(key, paths, options) { return __awaiter(this, void 0, void 0, function* () { const httpClient = createHttpClient(); - const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); + const version = utils.getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); const reserveCacheRequest = { key, version, @@ -491,20 +2433,30 @@ function commitCache(httpClient, cacheId, filesize) { })); }); } -function saveCache(cacheId, archivePath, options) { +function saveCache(cacheId, archivePath, signedUploadURL, options) { return __awaiter(this, void 0, void 0, function* () { - const httpClient = createHttpClient(); - core.debug('Upload cache'); - yield uploadFile(httpClient, cacheId, archivePath, options); - // Commit Cache - core.debug('Commiting cache'); - const cacheSize = utils.getArchiveFileSizeInBytes(archivePath); - core.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`); - const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize); - if (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode)) { - throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`); + const uploadOptions = (0, options_1.getUploadOptions)(options); + if (uploadOptions.useAzureSdk) { + // Use Azure storage SDK to upload caches directly to Azure + if (!signedUploadURL) { + throw new Error('Azure Storage SDK can only be used when a signed URL is provided.'); + } + yield (0, uploadUtils_1.uploadCacheArchiveSDK)(signedUploadURL, archivePath, options); + } + else { + const httpClient = createHttpClient(); + core.debug('Upload cache'); + yield uploadFile(httpClient, cacheId, archivePath, options); + // Commit Cache + core.debug('Commiting cache'); + const cacheSize = utils.getArchiveFileSizeInBytes(archivePath); + core.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`); + const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize); + if (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode)) { + throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`); + } + core.info('Cache saved successfully'); } - core.info('Cache saved successfully'); }); } exports.saveCache = saveCache; @@ -557,17 +2509,18 @@ var __asyncValues = (this && this.__asyncValues) || function (o) { function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.isGhes = exports.assertDefined = exports.getGnuTarPathOnWindows = exports.getCacheFileName = exports.getCompressionMethod = exports.unlinkFile = exports.resolvePaths = exports.getArchiveFileSizeInBytes = exports.createTempDirectory = void 0; +exports.getRuntimeToken = exports.getCacheVersion = exports.assertDefined = exports.getGnuTarPathOnWindows = exports.getCacheFileName = exports.getCompressionMethod = exports.unlinkFile = exports.resolvePaths = exports.getArchiveFileSizeInBytes = exports.createTempDirectory = void 0; const core = __importStar(__nccwpck_require__(2186)); const exec = __importStar(__nccwpck_require__(1514)); const glob = __importStar(__nccwpck_require__(1597)); const io = __importStar(__nccwpck_require__(7436)); +const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const path = __importStar(__nccwpck_require__(1017)); const semver = __importStar(__nccwpck_require__(3771)); const util = __importStar(__nccwpck_require__(3837)); -const uuid_1 = __nccwpck_require__(2155); const constants_1 = __nccwpck_require__(8840); +const versionSalt = '1.0'; // From https://github.com/actions/toolkit/blob/main/packages/tool-cache/src/tool-cache.ts#L23 function createTempDirectory() { return __awaiter(this, void 0, void 0, function* () { @@ -589,7 +2542,7 @@ function createTempDirectory() { } tempDirectory = path.join(baseLocation, 'actions', 'temp'); } - const dest = path.join(tempDirectory, (0, uuid_1.v4)()); + const dest = path.join(tempDirectory, crypto.randomUUID()); yield io.mkdirP(dest); return dest; }); @@ -705,15 +2658,76 @@ function assertDefined(name, value) { return value; } exports.assertDefined = assertDefined; +function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) { + // don't pass changes upstream + const components = paths.slice(); + // Add compression method to cache version to restore + // compressed cache as per compression method + if (compressionMethod) { + components.push(compressionMethod); + } + // Only check for windows platforms if enableCrossOsArchive is false + if (process.platform === 'win32' && !enableCrossOsArchive) { + components.push('windows-only'); + } + // Add salt to cache version to support breaking changes in cache entry + components.push(versionSalt); + return crypto.createHash('sha256').update(components.join('|')).digest('hex'); +} +exports.getCacheVersion = getCacheVersion; +function getRuntimeToken() { + const token = process.env['ACTIONS_RUNTIME_TOKEN']; + if (!token) { + throw new Error('Unable to get the ACTIONS_RUNTIME_TOKEN env variable'); + } + return token; +} +exports.getRuntimeToken = getRuntimeToken; +//# sourceMappingURL=cacheUtils.js.map + +/***/ }), + +/***/ 5147: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getCacheServiceURL = exports.getCacheServiceVersion = exports.isGhes = void 0; function isGhes() { const ghUrl = new URL(process.env['GITHUB_SERVER_URL'] || 'https://github.com'); const hostname = ghUrl.hostname.trimEnd().toUpperCase(); const isGitHubHost = hostname === 'GITHUB.COM'; - const isGheHost = hostname.endsWith('.GHE.COM') || hostname.endsWith('.GHE.LOCALHOST'); - return !isGitHubHost && !isGheHost; + const isGheHost = hostname.endsWith('.GHE.COM'); + const isLocalHost = hostname.endsWith('.LOCALHOST'); + return !isGitHubHost && !isGheHost && !isLocalHost; } exports.isGhes = isGhes; -//# sourceMappingURL=cacheUtils.js.map +function getCacheServiceVersion() { + // Cache service v2 is not supported on GHES. We will default to + // cache service v1 even if the feature flag was enabled by user. + if (isGhes()) + return 'v1'; + return process.env['ACTIONS_CACHE_SERVICE_V2'] ? 'v2' : 'v1'; +} +exports.getCacheServiceVersion = getCacheServiceVersion; +function getCacheServiceURL() { + const version = getCacheServiceVersion(); + // Based on the version of the cache service, we will determine which + // URL to use. + switch (version) { + case 'v1': + return (process.env['ACTIONS_CACHE_URL'] || + process.env['ACTIONS_RESULTS_URL'] || + ''); + case 'v2': + return process.env['ACTIONS_RESULTS_URL'] || ''; + default: + throw new Error(`Unsupported cache service version: ${version}`); + } +} +exports.getCacheServiceURL = getCacheServiceURL; +//# sourceMappingURL=config.js.map /***/ }), @@ -723,7 +2737,7 @@ exports.isGhes = isGhes; "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.ManifestFilename = exports.TarFilename = exports.SystemTarPathOnWindows = exports.GnuTarPathOnWindows = exports.SocketTimeout = exports.DefaultRetryDelay = exports.DefaultRetryAttempts = exports.ArchiveToolType = exports.CompressionMethod = exports.CacheFilename = void 0; +exports.CacheFileSizeLimit = exports.ManifestFilename = exports.TarFilename = exports.SystemTarPathOnWindows = exports.GnuTarPathOnWindows = exports.SocketTimeout = exports.DefaultRetryDelay = exports.DefaultRetryAttempts = exports.ArchiveToolType = exports.CompressionMethod = exports.CacheFilename = void 0; var CacheFilename; (function (CacheFilename) { CacheFilename["Gzip"] = "cache.tgz"; @@ -756,6 +2770,7 @@ exports.GnuTarPathOnWindows = `${process.env['PROGRAMFILES']}\\Git\\usr\\bin\\ta exports.SystemTarPathOnWindows = `${process.env['SYSTEMDRIVE']}\\Windows\\System32\\tar.exe`; exports.TarFilename = 'cache.tar'; exports.ManifestFilename = 'manifest.txt'; +exports.CacheFileSizeLimit = 10 * Math.pow(1024, 3); // 10GiB per repository //# sourceMappingURL=constants.js.map /***/ }), @@ -1289,6 +3304,270 @@ exports.retryHttpClientResponse = retryHttpClientResponse; /***/ }), +/***/ 2502: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.internalCacheTwirpClient = void 0; +const core_1 = __nccwpck_require__(2186); +const user_agent_1 = __nccwpck_require__(580); +const errors_1 = __nccwpck_require__(8223); +const config_1 = __nccwpck_require__(5147); +const cacheUtils_1 = __nccwpck_require__(1518); +const auth_1 = __nccwpck_require__(5526); +const http_client_1 = __nccwpck_require__(6255); +const cache_twirp_1 = __nccwpck_require__(267); +/** + * This class is a wrapper around the CacheServiceClientJSON class generated by Twirp. + * + * It adds retry logic to the request method, which is not present in the generated client. + * + * This class is used to interact with cache service v2. + */ +class CacheServiceClient { + constructor(userAgent, maxAttempts, baseRetryIntervalMilliseconds, retryMultiplier) { + this.maxAttempts = 5; + this.baseRetryIntervalMilliseconds = 3000; + this.retryMultiplier = 1.5; + const token = (0, cacheUtils_1.getRuntimeToken)(); + this.baseUrl = (0, config_1.getCacheServiceURL)(); + if (maxAttempts) { + this.maxAttempts = maxAttempts; + } + if (baseRetryIntervalMilliseconds) { + this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds; + } + if (retryMultiplier) { + this.retryMultiplier = retryMultiplier; + } + this.httpClient = new http_client_1.HttpClient(userAgent, [ + new auth_1.BearerCredentialHandler(token) + ]); + } + // This function satisfies the Rpc interface. It is compatible with the JSON + // JSON generated client. + request(service, method, contentType, data) { + return __awaiter(this, void 0, void 0, function* () { + const url = new URL(`/twirp/${service}/${method}`, this.baseUrl).href; + (0, core_1.debug)(`[Request] ${method} ${url}`); + const headers = { + 'Content-Type': contentType + }; + try { + const { body } = yield this.retryableRequest(() => __awaiter(this, void 0, void 0, function* () { return this.httpClient.post(url, JSON.stringify(data), headers); })); + return body; + } + catch (error) { + throw new Error(`Failed to ${method}: ${error.message}`); + } + }); + } + retryableRequest(operation) { + return __awaiter(this, void 0, void 0, function* () { + let attempt = 0; + let errorMessage = ''; + let rawBody = ''; + while (attempt < this.maxAttempts) { + let isRetryable = false; + try { + const response = yield operation(); + const statusCode = response.message.statusCode; + rawBody = yield response.readBody(); + (0, core_1.debug)(`[Response] - ${response.message.statusCode}`); + (0, core_1.debug)(`Headers: ${JSON.stringify(response.message.headers, null, 2)}`); + const body = JSON.parse(rawBody); + (0, core_1.debug)(`Body: ${JSON.stringify(body, null, 2)}`); + if (this.isSuccessStatusCode(statusCode)) { + return { response, body }; + } + isRetryable = this.isRetryableHttpStatusCode(statusCode); + errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`; + if (body.msg) { + if (errors_1.UsageError.isUsageErrorMessage(body.msg)) { + throw new errors_1.UsageError(); + } + errorMessage = `${errorMessage}: ${body.msg}`; + } + } + catch (error) { + if (error instanceof SyntaxError) { + (0, core_1.debug)(`Raw Body: ${rawBody}`); + } + if (error instanceof errors_1.UsageError) { + throw error; + } + if (errors_1.NetworkError.isNetworkErrorCode(error === null || error === void 0 ? void 0 : error.code)) { + throw new errors_1.NetworkError(error === null || error === void 0 ? void 0 : error.code); + } + isRetryable = true; + errorMessage = error.message; + } + if (!isRetryable) { + throw new Error(`Received non-retryable error: ${errorMessage}`); + } + if (attempt + 1 === this.maxAttempts) { + throw new Error(`Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`); + } + const retryTimeMilliseconds = this.getExponentialRetryTimeMilliseconds(attempt); + (0, core_1.info)(`Attempt ${attempt + 1} of ${this.maxAttempts} failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`); + yield this.sleep(retryTimeMilliseconds); + attempt++; + } + throw new Error(`Request failed`); + }); + } + isSuccessStatusCode(statusCode) { + if (!statusCode) + return false; + return statusCode >= 200 && statusCode < 300; + } + isRetryableHttpStatusCode(statusCode) { + if (!statusCode) + return false; + const retryableStatusCodes = [ + http_client_1.HttpCodes.BadGateway, + http_client_1.HttpCodes.GatewayTimeout, + http_client_1.HttpCodes.InternalServerError, + http_client_1.HttpCodes.ServiceUnavailable, + http_client_1.HttpCodes.TooManyRequests + ]; + return retryableStatusCodes.includes(statusCode); + } + sleep(milliseconds) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(resolve => setTimeout(resolve, milliseconds)); + }); + } + getExponentialRetryTimeMilliseconds(attempt) { + if (attempt < 0) { + throw new Error('attempt should be a positive integer'); + } + if (attempt === 0) { + return this.baseRetryIntervalMilliseconds; + } + const minTime = this.baseRetryIntervalMilliseconds * Math.pow(this.retryMultiplier, attempt); + const maxTime = minTime * this.retryMultiplier; + // returns a random number between minTime and maxTime (exclusive) + return Math.trunc(Math.random() * (maxTime - minTime) + minTime); + } +} +function internalCacheTwirpClient(options) { + const client = new CacheServiceClient((0, user_agent_1.getUserAgentString)(), options === null || options === void 0 ? void 0 : options.maxAttempts, options === null || options === void 0 ? void 0 : options.retryIntervalMs, options === null || options === void 0 ? void 0 : options.retryMultiplier); + return new cache_twirp_1.CacheServiceClientJSON(client); +} +exports.internalCacheTwirpClient = internalCacheTwirpClient; +//# sourceMappingURL=cacheTwirpClient.js.map + +/***/ }), + +/***/ 8223: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.UsageError = exports.NetworkError = exports.GHESNotSupportedError = exports.CacheNotFoundError = exports.InvalidResponseError = exports.FilesNotFoundError = void 0; +class FilesNotFoundError extends Error { + constructor(files = []) { + let message = 'No files were found to upload'; + if (files.length > 0) { + message += `: ${files.join(', ')}`; + } + super(message); + this.files = files; + this.name = 'FilesNotFoundError'; + } +} +exports.FilesNotFoundError = FilesNotFoundError; +class InvalidResponseError extends Error { + constructor(message) { + super(message); + this.name = 'InvalidResponseError'; + } +} +exports.InvalidResponseError = InvalidResponseError; +class CacheNotFoundError extends Error { + constructor(message = 'Cache not found') { + super(message); + this.name = 'CacheNotFoundError'; + } +} +exports.CacheNotFoundError = CacheNotFoundError; +class GHESNotSupportedError extends Error { + constructor(message = '@actions/cache v4.1.4+, actions/cache/save@v4+ and actions/cache/restore@v4+ are not currently supported on GHES.') { + super(message); + this.name = 'GHESNotSupportedError'; + } +} +exports.GHESNotSupportedError = GHESNotSupportedError; +class NetworkError extends Error { + constructor(code) { + const message = `Unable to make request: ${code}\nIf you are using self-hosted runners, please make sure your runner has access to all GitHub endpoints: https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners#communication-between-self-hosted-runners-and-github`; + super(message); + this.code = code; + this.name = 'NetworkError'; + } +} +exports.NetworkError = NetworkError; +NetworkError.isNetworkErrorCode = (code) => { + if (!code) + return false; + return [ + 'ECONNRESET', + 'ENOTFOUND', + 'ETIMEDOUT', + 'ECONNREFUSED', + 'EHOSTUNREACH' + ].includes(code); +}; +class UsageError extends Error { + constructor() { + const message = `Cache storage quota has been hit. Unable to upload any new cache entries. Usage is recalculated every 6-12 hours.\nMore info on storage limits: https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions#calculating-minute-and-storage-spending`; + super(message); + this.name = 'UsageError'; + } +} +exports.UsageError = UsageError; +UsageError.isUsageErrorMessage = (msg) => { + if (!msg) + return false; + return msg.includes('insufficient usage'); +}; +//# sourceMappingURL=errors.js.map + +/***/ }), + +/***/ 580: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getUserAgentString = void 0; +// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports +const packageJson = __nccwpck_require__(9167); +/** + * Ensure that this User Agent String is used in all HTTP calls so that we can monitor telemetry between different versions of this package + */ +function getUserAgentString() { + return `@actions/cache-${packageJson.version}`; +} +exports.getUserAgentString = getUserAgentString; +//# sourceMappingURL=user-agent.js.map + +/***/ }), + /***/ 6490: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -1568,6 +3847,180 @@ exports.createTar = createTar; /***/ }), +/***/ 1786: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.uploadCacheArchiveSDK = exports.UploadProgress = void 0; +const core = __importStar(__nccwpck_require__(2186)); +const storage_blob_1 = __nccwpck_require__(4100); +const errors_1 = __nccwpck_require__(8223); +/** + * Class for tracking the upload state and displaying stats. + */ +class UploadProgress { + constructor(contentLength) { + this.contentLength = contentLength; + this.sentBytes = 0; + this.displayedComplete = false; + this.startTime = Date.now(); + } + /** + * Sets the number of bytes sent + * + * @param sentBytes the number of bytes sent + */ + setSentBytes(sentBytes) { + this.sentBytes = sentBytes; + } + /** + * Returns the total number of bytes transferred. + */ + getTransferredBytes() { + return this.sentBytes; + } + /** + * Returns true if the upload is complete. + */ + isDone() { + return this.getTransferredBytes() === this.contentLength; + } + /** + * Prints the current upload stats. Once the upload completes, this will print one + * last line and then stop. + */ + display() { + if (this.displayedComplete) { + return; + } + const transferredBytes = this.sentBytes; + const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1); + const elapsedTime = Date.now() - this.startTime; + const uploadSpeed = (transferredBytes / + (1024 * 1024) / + (elapsedTime / 1000)).toFixed(1); + core.info(`Sent ${transferredBytes} of ${this.contentLength} (${percentage}%), ${uploadSpeed} MBs/sec`); + if (this.isDone()) { + this.displayedComplete = true; + } + } + /** + * Returns a function used to handle TransferProgressEvents. + */ + onProgress() { + return (progress) => { + this.setSentBytes(progress.loadedBytes); + }; + } + /** + * Starts the timer that displays the stats. + * + * @param delayInMs the delay between each write + */ + startDisplayTimer(delayInMs = 1000) { + const displayCallback = () => { + this.display(); + if (!this.isDone()) { + this.timeoutHandle = setTimeout(displayCallback, delayInMs); + } + }; + this.timeoutHandle = setTimeout(displayCallback, delayInMs); + } + /** + * Stops the timer that displays the stats. As this typically indicates the upload + * is complete, this will display one last line, unless the last line has already + * been written. + */ + stopDisplayTimer() { + if (this.timeoutHandle) { + clearTimeout(this.timeoutHandle); + this.timeoutHandle = undefined; + } + this.display(); + } +} +exports.UploadProgress = UploadProgress; +/** + * Uploads a cache archive directly to Azure Blob Storage using the Azure SDK. + * This function will display progress information to the console. Concurrency of the + * upload is determined by the calling functions. + * + * @param signedUploadURL + * @param archivePath + * @param options + * @returns + */ +function uploadCacheArchiveSDK(signedUploadURL, archivePath, options) { + var _a; + return __awaiter(this, void 0, void 0, function* () { + const blobClient = new storage_blob_1.BlobClient(signedUploadURL); + const blockBlobClient = blobClient.getBlockBlobClient(); + const uploadProgress = new UploadProgress((_a = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a !== void 0 ? _a : 0); + // Specify data transfer options + const uploadOptions = { + blockSize: options === null || options === void 0 ? void 0 : options.uploadChunkSize, + concurrency: options === null || options === void 0 ? void 0 : options.uploadConcurrency, + maxSingleShotSize: 128 * 1024 * 1024, + onProgress: uploadProgress.onProgress() + }; + try { + uploadProgress.startDisplayTimer(); + core.debug(`BlobClient: ${blobClient.name}:${blobClient.accountName}:${blobClient.containerName}`); + const response = yield blockBlobClient.uploadFile(archivePath, uploadOptions); + // TODO: better management of non-retryable errors + if (response._response.status >= 400) { + throw new errors_1.InvalidResponseError(`uploadCacheArchiveSDK: upload failed with status code ${response._response.status}`); + } + return response; + } + catch (error) { + core.warning(`uploadCacheArchiveSDK: internal error uploading cache archive: ${error.message}`); + throw error; + } + finally { + uploadProgress.stopDisplayTimer(); + } + }); +} +exports.uploadCacheArchiveSDK = uploadCacheArchiveSDK; +//# sourceMappingURL=uploadUtils.js.map + +/***/ }), + /***/ 6215: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -1605,11 +4058,16 @@ const core = __importStar(__nccwpck_require__(2186)); * @param copy the original upload options */ function getUploadOptions(copy) { + // Defaults if not overriden const result = { + useAzureSdk: false, uploadConcurrency: 4, uploadChunkSize: 32 * 1024 * 1024 }; if (copy) { + if (typeof copy.useAzureSdk === 'boolean') { + result.useAzureSdk = copy.useAzureSdk; + } if (typeof copy.uploadConcurrency === 'number') { result.uploadConcurrency = copy.uploadConcurrency; } @@ -1617,6 +4075,18 @@ function getUploadOptions(copy) { result.uploadChunkSize = copy.uploadChunkSize; } } + /** + * Add env var overrides + */ + // Cap the uploadConcurrency at 32 + result.uploadConcurrency = !isNaN(Number(process.env['CACHE_UPLOAD_CONCURRENCY'])) + ? Math.min(32, Number(process.env['CACHE_UPLOAD_CONCURRENCY'])) + : result.uploadConcurrency; + // Cap the uploadChunkSize at 128MiB + result.uploadChunkSize = !isNaN(Number(process.env['CACHE_UPLOAD_CHUNK_SIZE'])) + ? Math.min(128 * 1024 * 1024, Number(process.env['CACHE_UPLOAD_CHUNK_SIZE']) * 1024 * 1024) + : result.uploadChunkSize; + core.debug(`Use Azure SDK: ${result.useAzureSdk}`); core.debug(`Upload concurrency: ${result.uploadConcurrency}`); core.debug(`Upload chunk size: ${result.uploadChunkSize}`); return result; @@ -4395,7 +6865,11 @@ function coerce (version, options) { var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4408,7 +6882,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4470,13 +6944,13 @@ class Command { } } function escapeData(s) { - return utils_1.toCommandValue(s) + return (0, utils_1.toCommandValue)(s) .replace(/%/g, '%25') .replace(/\r/g, '%0D') .replace(/\n/g, '%0A'); } function escapeProperty(s) { - return utils_1.toCommandValue(s) + return (0, utils_1.toCommandValue)(s) .replace(/%/g, '%25') .replace(/\r/g, '%0D') .replace(/\n/g, '%0A') @@ -4494,7 +6968,11 @@ function escapeProperty(s) { var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4507,7 +6985,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4521,7 +6999,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; +exports.platform = exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = exports.markdownSummary = exports.summary = exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; const command_1 = __nccwpck_require__(7351); const file_command_1 = __nccwpck_require__(717); const utils_1 = __nccwpck_require__(5278); @@ -4541,7 +7019,7 @@ var ExitCode; * A code indicating that the action was a failure */ ExitCode[ExitCode["Failure"] = 1] = "Failure"; -})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +})(ExitCode || (exports.ExitCode = ExitCode = {})); //----------------------------------------------------------------------- // Variables //----------------------------------------------------------------------- @@ -4552,13 +7030,13 @@ var ExitCode; */ // eslint-disable-next-line @typescript-eslint/no-explicit-any function exportVariable(name, val) { - const convertedVal = utils_1.toCommandValue(val); + const convertedVal = (0, utils_1.toCommandValue)(val); process.env[name] = convertedVal; const filePath = process.env['GITHUB_ENV'] || ''; if (filePath) { - return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); + return (0, file_command_1.issueFileCommand)('ENV', (0, file_command_1.prepareKeyValueMessage)(name, val)); } - command_1.issueCommand('set-env', { name }, convertedVal); + (0, command_1.issueCommand)('set-env', { name }, convertedVal); } exports.exportVariable = exportVariable; /** @@ -4566,7 +7044,7 @@ exports.exportVariable = exportVariable; * @param secret value of the secret */ function setSecret(secret) { - command_1.issueCommand('add-mask', {}, secret); + (0, command_1.issueCommand)('add-mask', {}, secret); } exports.setSecret = setSecret; /** @@ -4576,10 +7054,10 @@ exports.setSecret = setSecret; function addPath(inputPath) { const filePath = process.env['GITHUB_PATH'] || ''; if (filePath) { - file_command_1.issueFileCommand('PATH', inputPath); + (0, file_command_1.issueFileCommand)('PATH', inputPath); } else { - command_1.issueCommand('add-path', {}, inputPath); + (0, command_1.issueCommand)('add-path', {}, inputPath); } process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; } @@ -4654,10 +7132,10 @@ exports.getBooleanInput = getBooleanInput; function setOutput(name, value) { const filePath = process.env['GITHUB_OUTPUT'] || ''; if (filePath) { - return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value)); + return (0, file_command_1.issueFileCommand)('OUTPUT', (0, file_command_1.prepareKeyValueMessage)(name, value)); } process.stdout.write(os.EOL); - command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); + (0, command_1.issueCommand)('set-output', { name }, (0, utils_1.toCommandValue)(value)); } exports.setOutput = setOutput; /** @@ -4666,7 +7144,7 @@ exports.setOutput = setOutput; * */ function setCommandEcho(enabled) { - command_1.issue('echo', enabled ? 'on' : 'off'); + (0, command_1.issue)('echo', enabled ? 'on' : 'off'); } exports.setCommandEcho = setCommandEcho; //----------------------------------------------------------------------- @@ -4697,7 +7175,7 @@ exports.isDebug = isDebug; * @param message debug message */ function debug(message) { - command_1.issueCommand('debug', {}, message); + (0, command_1.issueCommand)('debug', {}, message); } exports.debug = debug; /** @@ -4706,7 +7184,7 @@ exports.debug = debug; * @param properties optional properties to add to the annotation. */ function error(message, properties = {}) { - command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('error', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.error = error; /** @@ -4715,7 +7193,7 @@ exports.error = error; * @param properties optional properties to add to the annotation. */ function warning(message, properties = {}) { - command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('warning', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.warning = warning; /** @@ -4724,7 +7202,7 @@ exports.warning = warning; * @param properties optional properties to add to the annotation. */ function notice(message, properties = {}) { - command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('notice', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.notice = notice; /** @@ -4743,14 +7221,14 @@ exports.info = info; * @param name The name of the output group */ function startGroup(name) { - command_1.issue('group', name); + (0, command_1.issue)('group', name); } exports.startGroup = startGroup; /** * End an output group. */ function endGroup() { - command_1.issue('endgroup'); + (0, command_1.issue)('endgroup'); } exports.endGroup = endGroup; /** @@ -4788,9 +7266,9 @@ exports.group = group; function saveState(name, value) { const filePath = process.env['GITHUB_STATE'] || ''; if (filePath) { - return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value)); + return (0, file_command_1.issueFileCommand)('STATE', (0, file_command_1.prepareKeyValueMessage)(name, value)); } - command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value)); + (0, command_1.issueCommand)('save-state', { name }, (0, utils_1.toCommandValue)(value)); } exports.saveState = saveState; /** @@ -4826,6 +7304,10 @@ var path_utils_1 = __nccwpck_require__(2981); Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); +/** + * Platform utilities exports + */ +exports.platform = __importStar(__nccwpck_require__(5243)); //# sourceMappingURL=core.js.map /***/ }), @@ -4838,7 +7320,11 @@ Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: funct // For internal use, subject to change. var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4851,7 +7337,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4859,9 +7345,9 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; // We use any as a valid input type /* eslint-disable @typescript-eslint/no-explicit-any */ +const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const os = __importStar(__nccwpck_require__(2037)); -const uuid_1 = __nccwpck_require__(8974); const utils_1 = __nccwpck_require__(5278); function issueFileCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; @@ -4871,14 +7357,14 @@ function issueFileCommand(command, message) { if (!fs.existsSync(filePath)) { throw new Error(`Missing file at path: ${filePath}`); } - fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { + fs.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { encoding: 'utf8' }); } exports.issueFileCommand = issueFileCommand; function prepareKeyValueMessage(key, value) { - const delimiter = `ghadelimiter_${uuid_1.v4()}`; - const convertedValue = utils_1.toCommandValue(value); + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); // These should realistically never happen, but just in case someone finds a // way to exploit uuid generation let's not allow keys or values that contain // the delimiter. @@ -4963,9 +7449,9 @@ class OidcClient { const encodedAudience = encodeURIComponent(audience); id_token_url = `${id_token_url}&audience=${encodedAudience}`; } - core_1.debug(`ID token url is ${id_token_url}`); + (0, core_1.debug)(`ID token url is ${id_token_url}`); const id_token = yield OidcClient.getCall(id_token_url); - core_1.setSecret(id_token); + (0, core_1.setSecret)(id_token); return id_token; } catch (error) { @@ -4986,7 +7472,11 @@ exports.OidcClient = OidcClient; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4999,7 +7489,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -5044,6 +7534,107 @@ exports.toPlatformPath = toPlatformPath; /***/ }), +/***/ 5243: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getDetails = exports.isLinux = exports.isMacOS = exports.isWindows = exports.arch = exports.platform = void 0; +const os_1 = __importDefault(__nccwpck_require__(2037)); +const exec = __importStar(__nccwpck_require__(1514)); +const getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', undefined, { + silent: true + }); + const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', undefined, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; +}); +const getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a, _b, _c, _d; + const { stdout } = yield exec.getExecOutput('sw_vers', undefined, { + silent: true + }); + const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : ''; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ''; + return { + name, + version + }; +}); +const getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], { + silent: true + }); + const [name, version] = stdout.trim().split('\n'); + return { + name, + version + }; +}); +exports.platform = os_1.default.platform(); +exports.arch = os_1.default.arch(); +exports.isWindows = exports.platform === 'win32'; +exports.isMacOS = exports.platform === 'darwin'; +exports.isLinux = exports.platform === 'linux'; +function getDetails() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, (yield (exports.isWindows + ? getWindowsInfo() + : exports.isMacOS + ? getMacOsInfo() + : getLinuxInfo()))), { platform: exports.platform, + arch: exports.arch, + isWindows: exports.isWindows, + isMacOS: exports.isMacOS, + isLinux: exports.isLinux }); + }); +} +exports.getDetails = getDetails; +//# sourceMappingURL=platform.js.map + +/***/ }), + /***/ 1327: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -5381,652 +7972,6 @@ exports.toCommandProperties = toCommandProperties; /***/ }), -/***/ 8974: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -Object.defineProperty(exports, "v1", ({ - enumerable: true, - get: function () { - return _v.default; - } -})); -Object.defineProperty(exports, "v3", ({ - enumerable: true, - get: function () { - return _v2.default; - } -})); -Object.defineProperty(exports, "v4", ({ - enumerable: true, - get: function () { - return _v3.default; - } -})); -Object.defineProperty(exports, "v5", ({ - enumerable: true, - get: function () { - return _v4.default; - } -})); -Object.defineProperty(exports, "NIL", ({ - enumerable: true, - get: function () { - return _nil.default; - } -})); -Object.defineProperty(exports, "version", ({ - enumerable: true, - get: function () { - return _version.default; - } -})); -Object.defineProperty(exports, "validate", ({ - enumerable: true, - get: function () { - return _validate.default; - } -})); -Object.defineProperty(exports, "stringify", ({ - enumerable: true, - get: function () { - return _stringify.default; - } -})); -Object.defineProperty(exports, "parse", ({ - enumerable: true, - get: function () { - return _parse.default; - } -})); - -var _v = _interopRequireDefault(__nccwpck_require__(1595)); - -var _v2 = _interopRequireDefault(__nccwpck_require__(6993)); - -var _v3 = _interopRequireDefault(__nccwpck_require__(1472)); - -var _v4 = _interopRequireDefault(__nccwpck_require__(6217)); - -var _nil = _interopRequireDefault(__nccwpck_require__(2381)); - -var _version = _interopRequireDefault(__nccwpck_require__(427)); - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -var _parse = _interopRequireDefault(__nccwpck_require__(6385)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/***/ }), - -/***/ 5842: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function md5(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('md5').update(bytes).digest(); -} - -var _default = md5; -exports["default"] = _default; - -/***/ }), - -/***/ 2381: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = '00000000-0000-0000-0000-000000000000'; -exports["default"] = _default; - -/***/ }), - -/***/ 6385: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function parse(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - let v; - const arr = new Uint8Array(16); // Parse ########-....-....-....-............ - - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; // Parse ........-####-....-....-............ - - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; // Parse ........-....-####-....-............ - - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; // Parse ........-....-....-####-............ - - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} - -var _default = parse; -exports["default"] = _default; - -/***/ }), - -/***/ 6230: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; -exports["default"] = _default; - -/***/ }), - -/***/ 9784: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = rng; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate - -let poolPtr = rnds8Pool.length; - -function rng() { - if (poolPtr > rnds8Pool.length - 16) { - _crypto.default.randomFillSync(rnds8Pool); - - poolPtr = 0; - } - - return rnds8Pool.slice(poolPtr, poolPtr += 16); -} - -/***/ }), - -/***/ 8844: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function sha1(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('sha1').update(bytes).digest(); -} - -var _default = sha1; -exports["default"] = _default; - -/***/ }), - -/***/ 1458: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -const byteToHex = []; - -for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).substr(1)); -} - -function stringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - - if (!(0, _validate.default)(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - - return uuid; -} - -var _default = stringify; -exports["default"] = _default; - -/***/ }), - -/***/ 1595: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(9784)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html -let _nodeId; - -let _clockseq; // Previous uuid creation time - - -let _lastMSecs = 0; -let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details - -function v1(options, buf, offset) { - let i = buf && offset || 0; - const b = buf || new Array(16); - options = options || {}; - let node = options.node || _nodeId; - let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - - if (node == null || clockseq == null) { - const seedBytes = options.random || (options.rng || _rng.default)(); - - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - } - - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - } - } // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - - - let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - - let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) - - const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression - - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - - - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } // Per 4.2.1.2 Throw error if too many uuids are requested - - - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - - msecs += 12219292800000; // `time_low` - - const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; // `time_mid` - - const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; // `time_high_and_version` - - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - - b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - - b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` - - b[i++] = clockseq & 0xff; // `node` - - for (let n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf || (0, _stringify.default)(b); -} - -var _default = v1; -exports["default"] = _default; - -/***/ }), - -/***/ 6993: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(5920)); - -var _md = _interopRequireDefault(__nccwpck_require__(5842)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v3 = (0, _v.default)('v3', 0x30, _md.default); -var _default = v3; -exports["default"] = _default; - -/***/ }), - -/***/ 5920: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = _default; -exports.URL = exports.DNS = void 0; - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -var _parse = _interopRequireDefault(__nccwpck_require__(6385)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - const bytes = []; - - for (let i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - - return bytes; -} - -const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -exports.DNS = DNS; -const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -exports.URL = URL; - -function _default(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - if (typeof value === 'string') { - value = stringToBytes(value); - } - - if (typeof namespace === 'string') { - namespace = (0, _parse.default)(namespace); - } - - if (namespace.length !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - - - let bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - - return buf; - } - - return (0, _stringify.default)(bytes); - } // Function#name is not settable on some platforms (#270) - - - try { - generateUUID.name = name; // eslint-disable-next-line no-empty - } catch (err) {} // For CommonJS default export support - - - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} - -/***/ }), - -/***/ 1472: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(9784)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function v4(options, buf, offset) { - options = options || {}; - - const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - - - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - - return buf; - } - - return (0, _stringify.default)(rnds); -} - -var _default = v4; -exports["default"] = _default; - -/***/ }), - -/***/ 6217: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(5920)); - -var _sha = _interopRequireDefault(__nccwpck_require__(8844)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v5 = (0, _v.default)('v5', 0x50, _sha.default); -var _default = v5; -exports["default"] = _default; - -/***/ }), - -/***/ 2609: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _regex = _interopRequireDefault(__nccwpck_require__(6230)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function validate(uuid) { - return typeof uuid === 'string' && _regex.default.test(uuid); -} - -var _default = validate; -exports["default"] = _default; - -/***/ }), - -/***/ 427: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function version(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - return parseInt(uuid.substr(14, 1), 16); -} - -var _default = version; -exports["default"] = _default; - -/***/ }), - /***/ 1514: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -45108,6 +47053,4940 @@ exports.VERSION = void 0; exports.VERSION = '1.7.0'; //# sourceMappingURL=version.js.map +/***/ }), + +/***/ 9912: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ClientStreamingCall = void 0; +/** + * A client streaming RPC call. This means that the clients sends 0, 1, or + * more messages to the server, and the server replies with exactly one + * message. + */ +class ClientStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.requests = request; + this.headers = headers; + this.response = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * Note that it may still be valid to send more request messages. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, response, status, trailers] = yield Promise.all([this.headers, this.response, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + headers, + response, + status, + trailers + }; + }); + } +} +exports.ClientStreamingCall = ClientStreamingCall; + + +/***/ }), + +/***/ 5702: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Deferred = exports.DeferredState = void 0; +var DeferredState; +(function (DeferredState) { + DeferredState[DeferredState["PENDING"] = 0] = "PENDING"; + DeferredState[DeferredState["REJECTED"] = 1] = "REJECTED"; + DeferredState[DeferredState["RESOLVED"] = 2] = "RESOLVED"; +})(DeferredState = exports.DeferredState || (exports.DeferredState = {})); +/** + * A deferred promise. This is a "controller" for a promise, which lets you + * pass a promise around and reject or resolve it from the outside. + * + * Warning: This class is to be used with care. Using it can make code very + * difficult to read. It is intended for use in library code that exposes + * promises, not for regular business logic. + */ +class Deferred { + /** + * @param preventUnhandledRejectionWarning - prevents the warning + * "Unhandled Promise rejection" by adding a noop rejection handler. + * Working with calls returned from the runtime-rpc package in an + * async function usually means awaiting one call property after + * the other. This means that the "status" is not being awaited when + * an earlier await for the "headers" is rejected. This causes the + * "unhandled promise reject" warning. A more correct behaviour for + * calls might be to become aware whether at least one of the + * promises is handled and swallow the rejection warning for the + * others. + */ + constructor(preventUnhandledRejectionWarning = true) { + this._state = DeferredState.PENDING; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + if (preventUnhandledRejectionWarning) { + this._promise.catch(_ => { }); + } + } + /** + * Get the current state of the promise. + */ + get state() { + return this._state; + } + /** + * Get the deferred promise. + */ + get promise() { + return this._promise; + } + /** + * Resolve the promise. Throws if the promise is already resolved or rejected. + */ + resolve(value) { + if (this.state !== DeferredState.PENDING) + throw new Error(`cannot resolve ${DeferredState[this.state].toLowerCase()}`); + this._resolve(value); + this._state = DeferredState.RESOLVED; + } + /** + * Reject the promise. Throws if the promise is already resolved or rejected. + */ + reject(reason) { + if (this.state !== DeferredState.PENDING) + throw new Error(`cannot reject ${DeferredState[this.state].toLowerCase()}`); + this._reject(reason); + this._state = DeferredState.REJECTED; + } + /** + * Resolve the promise. Ignore if not pending. + */ + resolvePending(val) { + if (this._state === DeferredState.PENDING) + this.resolve(val); + } + /** + * Reject the promise. Ignore if not pending. + */ + rejectPending(reason) { + if (this._state === DeferredState.PENDING) + this.reject(reason); + } +} +exports.Deferred = Deferred; + + +/***/ }), + +/***/ 7042: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.DuplexStreamingCall = void 0; +/** + * A duplex streaming RPC call. This means that the clients sends an + * arbitrary amount of messages to the server, while at the same time, + * the server sends an arbitrary amount of messages to the client. + */ +class DuplexStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.requests = request; + this.headers = headers; + this.responses = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * Note that it may still be valid to send more request messages. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, status, trailers] = yield Promise.all([this.headers, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + headers, + status, + trailers, + }; + }); + } +} +exports.DuplexStreamingCall = DuplexStreamingCall; + + +/***/ }), + +/***/ 12: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +// Public API of the rpc runtime. +// Note: we do not use `export * from ...` to help tree shakers, +// webpack verbose output hints that this should be useful +Object.defineProperty(exports, "__esModule", ({ value: true })); +var service_type_1 = __nccwpck_require__(4107); +Object.defineProperty(exports, "ServiceType", ({ enumerable: true, get: function () { return service_type_1.ServiceType; } })); +var reflection_info_1 = __nccwpck_require__(4331); +Object.defineProperty(exports, "readMethodOptions", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOptions; } })); +Object.defineProperty(exports, "readMethodOption", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOption; } })); +Object.defineProperty(exports, "readServiceOption", ({ enumerable: true, get: function () { return reflection_info_1.readServiceOption; } })); +var rpc_error_1 = __nccwpck_require__(3159); +Object.defineProperty(exports, "RpcError", ({ enumerable: true, get: function () { return rpc_error_1.RpcError; } })); +var rpc_options_1 = __nccwpck_require__(7386); +Object.defineProperty(exports, "mergeRpcOptions", ({ enumerable: true, get: function () { return rpc_options_1.mergeRpcOptions; } })); +var rpc_output_stream_1 = __nccwpck_require__(6637); +Object.defineProperty(exports, "RpcOutputStreamController", ({ enumerable: true, get: function () { return rpc_output_stream_1.RpcOutputStreamController; } })); +var test_transport_1 = __nccwpck_require__(7008); +Object.defineProperty(exports, "TestTransport", ({ enumerable: true, get: function () { return test_transport_1.TestTransport; } })); +var deferred_1 = __nccwpck_require__(5702); +Object.defineProperty(exports, "Deferred", ({ enumerable: true, get: function () { return deferred_1.Deferred; } })); +Object.defineProperty(exports, "DeferredState", ({ enumerable: true, get: function () { return deferred_1.DeferredState; } })); +var duplex_streaming_call_1 = __nccwpck_require__(7042); +Object.defineProperty(exports, "DuplexStreamingCall", ({ enumerable: true, get: function () { return duplex_streaming_call_1.DuplexStreamingCall; } })); +var client_streaming_call_1 = __nccwpck_require__(9912); +Object.defineProperty(exports, "ClientStreamingCall", ({ enumerable: true, get: function () { return client_streaming_call_1.ClientStreamingCall; } })); +var server_streaming_call_1 = __nccwpck_require__(66); +Object.defineProperty(exports, "ServerStreamingCall", ({ enumerable: true, get: function () { return server_streaming_call_1.ServerStreamingCall; } })); +var unary_call_1 = __nccwpck_require__(164); +Object.defineProperty(exports, "UnaryCall", ({ enumerable: true, get: function () { return unary_call_1.UnaryCall; } })); +var rpc_interceptor_1 = __nccwpck_require__(1680); +Object.defineProperty(exports, "stackIntercept", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackIntercept; } })); +Object.defineProperty(exports, "stackDuplexStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackDuplexStreamingInterceptors; } })); +Object.defineProperty(exports, "stackClientStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackClientStreamingInterceptors; } })); +Object.defineProperty(exports, "stackServerStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackServerStreamingInterceptors; } })); +Object.defineProperty(exports, "stackUnaryInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackUnaryInterceptors; } })); +var server_call_context_1 = __nccwpck_require__(5320); +Object.defineProperty(exports, "ServerCallContextController", ({ enumerable: true, get: function () { return server_call_context_1.ServerCallContextController; } })); + + +/***/ }), + +/***/ 4331: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.readServiceOption = exports.readMethodOption = exports.readMethodOptions = exports.normalizeMethodInfo = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Turns PartialMethodInfo into MethodInfo. + */ +function normalizeMethodInfo(method, service) { + var _a, _b, _c; + let m = method; + m.service = service; + m.localName = (_a = m.localName) !== null && _a !== void 0 ? _a : runtime_1.lowerCamelCase(m.name); + // noinspection PointlessBooleanExpressionJS + m.serverStreaming = !!m.serverStreaming; + // noinspection PointlessBooleanExpressionJS + m.clientStreaming = !!m.clientStreaming; + m.options = (_b = m.options) !== null && _b !== void 0 ? _b : {}; + m.idempotency = (_c = m.idempotency) !== null && _c !== void 0 ? _c : undefined; + return m; +} +exports.normalizeMethodInfo = normalizeMethodInfo; +/** + * Read custom method options from a generated service client. + * + * @deprecated use readMethodOption() + */ +function readMethodOptions(service, methodName, extensionName, extensionType) { + var _a; + const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options; + return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : undefined; +} +exports.readMethodOptions = readMethodOptions; +function readMethodOption(service, methodName, extensionName, extensionType) { + var _a; + const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readMethodOption = readMethodOption; +function readServiceOption(service, extensionName, extensionType) { + const options = service.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readServiceOption = readServiceOption; + + +/***/ }), + +/***/ 3159: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.RpcError = void 0; +/** + * An error that occurred while calling a RPC method. + */ +class RpcError extends Error { + constructor(message, code = 'UNKNOWN', meta) { + super(message); + this.name = 'RpcError'; + // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example + Object.setPrototypeOf(this, new.target.prototype); + this.code = code; + this.meta = meta !== null && meta !== void 0 ? meta : {}; + } + toString() { + const l = [this.name + ': ' + this.message]; + if (this.code) { + l.push(''); + l.push('Code: ' + this.code); + } + if (this.serviceName && this.methodName) { + l.push('Method: ' + this.serviceName + '/' + this.methodName); + } + let m = Object.entries(this.meta); + if (m.length) { + l.push(''); + l.push('Meta:'); + for (let [k, v] of m) { + l.push(` ${k}: ${v}`); + } + } + return l.join('\n'); + } +} +exports.RpcError = RpcError; + + +/***/ }), + +/***/ 1680: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.stackDuplexStreamingInterceptors = exports.stackClientStreamingInterceptors = exports.stackServerStreamingInterceptors = exports.stackUnaryInterceptors = exports.stackIntercept = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Creates a "stack" of of all interceptors specified in the given `RpcOptions`. + * Used by generated client implementations. + * @internal + */ +function stackIntercept(kind, transport, method, options, input) { + var _a, _b, _c, _d; + if (kind == "unary") { + let tail = (mtd, inp, opt) => transport.unary(mtd, inp, opt); + for (const curr of ((_a = options.interceptors) !== null && _a !== void 0 ? _a : []).filter(i => i.interceptUnary).reverse()) { + const next = tail; + tail = (mtd, inp, opt) => curr.interceptUnary(next, mtd, inp, opt); + } + return tail(method, input, options); + } + if (kind == "serverStreaming") { + let tail = (mtd, inp, opt) => transport.serverStreaming(mtd, inp, opt); + for (const curr of ((_b = options.interceptors) !== null && _b !== void 0 ? _b : []).filter(i => i.interceptServerStreaming).reverse()) { + const next = tail; + tail = (mtd, inp, opt) => curr.interceptServerStreaming(next, mtd, inp, opt); + } + return tail(method, input, options); + } + if (kind == "clientStreaming") { + let tail = (mtd, opt) => transport.clientStreaming(mtd, opt); + for (const curr of ((_c = options.interceptors) !== null && _c !== void 0 ? _c : []).filter(i => i.interceptClientStreaming).reverse()) { + const next = tail; + tail = (mtd, opt) => curr.interceptClientStreaming(next, mtd, opt); + } + return tail(method, options); + } + if (kind == "duplex") { + let tail = (mtd, opt) => transport.duplex(mtd, opt); + for (const curr of ((_d = options.interceptors) !== null && _d !== void 0 ? _d : []).filter(i => i.interceptDuplex).reverse()) { + const next = tail; + tail = (mtd, opt) => curr.interceptDuplex(next, mtd, opt); + } + return tail(method, options); + } + runtime_1.assertNever(kind); +} +exports.stackIntercept = stackIntercept; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackUnaryInterceptors(transport, method, input, options) { + return stackIntercept("unary", transport, method, options, input); +} +exports.stackUnaryInterceptors = stackUnaryInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackServerStreamingInterceptors(transport, method, input, options) { + return stackIntercept("serverStreaming", transport, method, options, input); +} +exports.stackServerStreamingInterceptors = stackServerStreamingInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackClientStreamingInterceptors(transport, method, options) { + return stackIntercept("clientStreaming", transport, method, options); +} +exports.stackClientStreamingInterceptors = stackClientStreamingInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackDuplexStreamingInterceptors(transport, method, options) { + return stackIntercept("duplex", transport, method, options); +} +exports.stackDuplexStreamingInterceptors = stackDuplexStreamingInterceptors; + + +/***/ }), + +/***/ 7386: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.mergeRpcOptions = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Merges custom RPC options with defaults. Returns a new instance and keeps + * the "defaults" and the "options" unmodified. + * + * Merges `RpcMetadata` "meta", overwriting values from "defaults" with + * values from "options". Does not append values to existing entries. + * + * Merges "jsonOptions", including "jsonOptions.typeRegistry", by creating + * a new array that contains types from "options.jsonOptions.typeRegistry" + * first, then types from "defaults.jsonOptions.typeRegistry". + * + * Merges "binaryOptions". + * + * Merges "interceptors" by creating a new array that contains interceptors + * from "defaults" first, then interceptors from "options". + * + * Works with objects that extend `RpcOptions`, but only if the added + * properties are of type Date, primitive like string, boolean, or Array + * of primitives. If you have other property types, you have to merge them + * yourself. + */ +function mergeRpcOptions(defaults, options) { + if (!options) + return defaults; + let o = {}; + copy(defaults, o); + copy(options, o); + for (let key of Object.keys(options)) { + let val = options[key]; + switch (key) { + case "jsonOptions": + o.jsonOptions = runtime_1.mergeJsonOptions(defaults.jsonOptions, o.jsonOptions); + break; + case "binaryOptions": + o.binaryOptions = runtime_1.mergeBinaryOptions(defaults.binaryOptions, o.binaryOptions); + break; + case "meta": + o.meta = {}; + copy(defaults.meta, o.meta); + copy(options.meta, o.meta); + break; + case "interceptors": + o.interceptors = defaults.interceptors ? defaults.interceptors.concat(val) : val.concat(); + break; + } + } + return o; +} +exports.mergeRpcOptions = mergeRpcOptions; +function copy(a, into) { + if (!a) + return; + let c = into; + for (let [k, v] of Object.entries(a)) { + if (v instanceof Date) + c[k] = new Date(v.getTime()); + else if (Array.isArray(v)) + c[k] = v.concat(); + else + c[k] = v; + } +} + + +/***/ }), + +/***/ 6637: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.RpcOutputStreamController = void 0; +const deferred_1 = __nccwpck_require__(5702); +const runtime_1 = __nccwpck_require__(4061); +/** + * A `RpcOutputStream` that you control. + */ +class RpcOutputStreamController { + constructor() { + this._lis = { + nxt: [], + msg: [], + err: [], + cmp: [], + }; + this._closed = false; + } + // --- RpcOutputStream callback API + onNext(callback) { + return this.addLis(callback, this._lis.nxt); + } + onMessage(callback) { + return this.addLis(callback, this._lis.msg); + } + onError(callback) { + return this.addLis(callback, this._lis.err); + } + onComplete(callback) { + return this.addLis(callback, this._lis.cmp); + } + addLis(callback, list) { + list.push(callback); + return () => { + let i = list.indexOf(callback); + if (i >= 0) + list.splice(i, 1); + }; + } + // remove all listeners + clearLis() { + for (let l of Object.values(this._lis)) + l.splice(0, l.length); + } + // --- Controller API + /** + * Is this stream already closed by a completion or error? + */ + get closed() { + return this._closed !== false; + } + /** + * Emit message, close with error, or close successfully, but only one + * at a time. + * Can be used to wrap a stream by using the other stream's `onNext`. + */ + notifyNext(message, error, complete) { + runtime_1.assert((message ? 1 : 0) + (error ? 1 : 0) + (complete ? 1 : 0) <= 1, 'only one emission at a time'); + if (message) + this.notifyMessage(message); + if (error) + this.notifyError(error); + if (complete) + this.notifyComplete(); + } + /** + * Emits a new message. Throws if stream is closed. + * + * Triggers onNext and onMessage callbacks. + */ + notifyMessage(message) { + runtime_1.assert(!this.closed, 'stream is closed'); + this.pushIt({ value: message, done: false }); + this._lis.msg.forEach(l => l(message)); + this._lis.nxt.forEach(l => l(message, undefined, false)); + } + /** + * Closes the stream with an error. Throws if stream is closed. + * + * Triggers onNext and onError callbacks. + */ + notifyError(error) { + runtime_1.assert(!this.closed, 'stream is closed'); + this._closed = error; + this.pushIt(error); + this._lis.err.forEach(l => l(error)); + this._lis.nxt.forEach(l => l(undefined, error, false)); + this.clearLis(); + } + /** + * Closes the stream successfully. Throws if stream is closed. + * + * Triggers onNext and onComplete callbacks. + */ + notifyComplete() { + runtime_1.assert(!this.closed, 'stream is closed'); + this._closed = true; + this.pushIt({ value: null, done: true }); + this._lis.cmp.forEach(l => l()); + this._lis.nxt.forEach(l => l(undefined, undefined, true)); + this.clearLis(); + } + /** + * Creates an async iterator (that can be used with `for await {...}`) + * to consume the stream. + * + * Some things to note: + * - If an error occurs, the `for await` will throw it. + * - If an error occurred before the `for await` was started, `for await` + * will re-throw it. + * - If the stream is already complete, the `for await` will be empty. + * - If your `for await` consumes slower than the stream produces, + * for example because you are relaying messages in a slow operation, + * messages are queued. + */ + [Symbol.asyncIterator]() { + // init the iterator state, enabling pushIt() + if (!this._itState) { + this._itState = { q: [] }; + } + // if we are closed, we are definitely not receiving any more messages. + // but we can't let the iterator get stuck. we want to either: + // a) finish the new iterator immediately, because we are completed + // b) reject the new iterator, because we errored + if (this._closed === true) + this.pushIt({ value: null, done: true }); + else if (this._closed !== false) + this.pushIt(this._closed); + // the async iterator + return { + next: () => { + let state = this._itState; + runtime_1.assert(state, "bad state"); // if we don't have a state here, code is broken + // there should be no pending result. + // did the consumer call next() before we resolved our previous result promise? + runtime_1.assert(!state.p, "iterator contract broken"); + // did we produce faster than the iterator consumed? + // return the oldest result from the queue. + let first = state.q.shift(); + if (first) + return ("value" in first) ? Promise.resolve(first) : Promise.reject(first); + // we have no result ATM, but we promise one. + // as soon as we have a result, we must resolve promise. + state.p = new deferred_1.Deferred(); + return state.p.promise; + }, + }; + } + // "push" a new iterator result. + // this either resolves a pending promise, or enqueues the result. + pushIt(result) { + let state = this._itState; + if (!state) + return; + // is the consumer waiting for us? + if (state.p) { + // yes, consumer is waiting for this promise. + const p = state.p; + runtime_1.assert(p.state == deferred_1.DeferredState.PENDING, "iterator contract broken"); + // resolve the promise + ("value" in result) ? p.resolve(result) : p.reject(result); + // must cleanup, otherwise iterator.next() would pick it up again. + delete state.p; + } + else { + // we are producing faster than the iterator consumes. + // push result onto queue. + state.q.push(result); + } + } +} +exports.RpcOutputStreamController = RpcOutputStreamController; + + +/***/ }), + +/***/ 5320: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServerCallContextController = void 0; +class ServerCallContextController { + constructor(method, headers, deadline, sendResponseHeadersFn, defaultStatus = { code: 'OK', detail: '' }) { + this._cancelled = false; + this._listeners = []; + this.method = method; + this.headers = headers; + this.deadline = deadline; + this.trailers = {}; + this._sendRH = sendResponseHeadersFn; + this.status = defaultStatus; + } + /** + * Set the call cancelled. + * + * Invokes all callbacks registered with onCancel() and + * sets `cancelled = true`. + */ + notifyCancelled() { + if (!this._cancelled) { + this._cancelled = true; + for (let l of this._listeners) { + l(); + } + } + } + /** + * Send response headers. + */ + sendResponseHeaders(data) { + this._sendRH(data); + } + /** + * Is the call cancelled? + * + * When the client closes the connection before the server + * is done, the call is cancelled. + * + * If you want to cancel a request on the server, throw a + * RpcError with the CANCELLED status code. + */ + get cancelled() { + return this._cancelled; + } + /** + * Add a callback for cancellation. + */ + onCancel(callback) { + const l = this._listeners; + l.push(callback); + return () => { + let i = l.indexOf(callback); + if (i >= 0) + l.splice(i, 1); + }; + } +} +exports.ServerCallContextController = ServerCallContextController; + + +/***/ }), + +/***/ 66: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServerStreamingCall = void 0; +/** + * A server streaming RPC call. The client provides exactly one input message + * but the server may respond with 0, 1, or more messages. + */ +class ServerStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.request = request; + this.headers = headers; + this.responses = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * You should first setup some listeners to the `request` to + * see the actual messages the server replied with. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, status, trailers] = yield Promise.all([this.headers, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + request: this.request, + headers, + status, + trailers, + }; + }); + } +} +exports.ServerStreamingCall = ServerStreamingCall; + + +/***/ }), + +/***/ 4107: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServiceType = void 0; +const reflection_info_1 = __nccwpck_require__(4331); +class ServiceType { + constructor(typeName, methods, options) { + this.typeName = typeName; + this.methods = methods.map(i => reflection_info_1.normalizeMethodInfo(i, this)); + this.options = options !== null && options !== void 0 ? options : {}; + } +} +exports.ServiceType = ServiceType; + + +/***/ }), + +/***/ 7008: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TestTransport = void 0; +const rpc_error_1 = __nccwpck_require__(3159); +const runtime_1 = __nccwpck_require__(4061); +const rpc_output_stream_1 = __nccwpck_require__(6637); +const rpc_options_1 = __nccwpck_require__(7386); +const unary_call_1 = __nccwpck_require__(164); +const server_streaming_call_1 = __nccwpck_require__(66); +const client_streaming_call_1 = __nccwpck_require__(9912); +const duplex_streaming_call_1 = __nccwpck_require__(7042); +/** + * Transport for testing. + */ +class TestTransport { + /** + * Initialize with mock data. Omitted fields have default value. + */ + constructor(data) { + /** + * Suppress warning / error about uncaught rejections of + * "status" and "trailers". + */ + this.suppressUncaughtRejections = true; + this.headerDelay = 10; + this.responseDelay = 50; + this.betweenResponseDelay = 10; + this.afterResponseDelay = 10; + this.data = data !== null && data !== void 0 ? data : {}; + } + /** + * Sent message(s) during the last operation. + */ + get sentMessages() { + if (this.lastInput instanceof TestInputStream) { + return this.lastInput.sent; + } + else if (typeof this.lastInput == "object") { + return [this.lastInput.single]; + } + return []; + } + /** + * Sending message(s) completed? + */ + get sendComplete() { + if (this.lastInput instanceof TestInputStream) { + return this.lastInput.completed; + } + else if (typeof this.lastInput == "object") { + return true; + } + return false; + } + // Creates a promise for response headers from the mock data. + promiseHeaders() { + var _a; + const headers = (_a = this.data.headers) !== null && _a !== void 0 ? _a : TestTransport.defaultHeaders; + return headers instanceof rpc_error_1.RpcError + ? Promise.reject(headers) + : Promise.resolve(headers); + } + // Creates a promise for a single, valid, message from the mock data. + promiseSingleResponse(method) { + if (this.data.response instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.response); + } + let r; + if (Array.isArray(this.data.response)) { + runtime_1.assert(this.data.response.length > 0); + r = this.data.response[0]; + } + else if (this.data.response !== undefined) { + r = this.data.response; + } + else { + r = method.O.create(); + } + runtime_1.assert(method.O.is(r)); + return Promise.resolve(r); + } + /** + * Pushes response messages from the mock data to the output stream. + * If an error response, status or trailers are mocked, the stream is + * closed with the respective error. + * Otherwise, stream is completed successfully. + * + * The returned promise resolves when the stream is closed. It should + * not reject. If it does, code is broken. + */ + streamResponses(method, stream, abort) { + return __awaiter(this, void 0, void 0, function* () { + // normalize "data.response" into an array of valid output messages + const messages = []; + if (this.data.response === undefined) { + messages.push(method.O.create()); + } + else if (Array.isArray(this.data.response)) { + for (let msg of this.data.response) { + runtime_1.assert(method.O.is(msg)); + messages.push(msg); + } + } + else if (!(this.data.response instanceof rpc_error_1.RpcError)) { + runtime_1.assert(method.O.is(this.data.response)); + messages.push(this.data.response); + } + // start the stream with an initial delay. + // if the request is cancelled, notify() error and exit. + try { + yield delay(this.responseDelay, abort)(undefined); + } + catch (error) { + stream.notifyError(error); + return; + } + // if error response was mocked, notify() error (stream is now closed with error) and exit. + if (this.data.response instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.response); + return; + } + // regular response messages were mocked. notify() them. + for (let msg of messages) { + stream.notifyMessage(msg); + // add a short delay between responses + // if the request is cancelled, notify() error and exit. + try { + yield delay(this.betweenResponseDelay, abort)(undefined); + } + catch (error) { + stream.notifyError(error); + return; + } + } + // error status was mocked, notify() error (stream is now closed with error) and exit. + if (this.data.status instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.status); + return; + } + // error trailers were mocked, notify() error (stream is now closed with error) and exit. + if (this.data.trailers instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.trailers); + return; + } + // stream completed successfully + stream.notifyComplete(); + }); + } + // Creates a promise for response status from the mock data. + promiseStatus() { + var _a; + const status = (_a = this.data.status) !== null && _a !== void 0 ? _a : TestTransport.defaultStatus; + return status instanceof rpc_error_1.RpcError + ? Promise.reject(status) + : Promise.resolve(status); + } + // Creates a promise for response trailers from the mock data. + promiseTrailers() { + var _a; + const trailers = (_a = this.data.trailers) !== null && _a !== void 0 ? _a : TestTransport.defaultTrailers; + return trailers instanceof rpc_error_1.RpcError + ? Promise.reject(trailers) + : Promise.resolve(trailers); + } + maybeSuppressUncaught(...promise) { + if (this.suppressUncaughtRejections) { + for (let p of promise) { + p.catch(() => { + }); + } + } + } + mergeOptions(options) { + return rpc_options_1.mergeRpcOptions({}, options); + } + unary(method, input, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), responsePromise = headersPromise + .catch(_ => { + }) + .then(delay(this.responseDelay, options.abort)) + .then(_ => this.promiseSingleResponse(method)), statusPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseStatus()), trailersPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = { single: input }; + return new unary_call_1.UnaryCall(method, requestHeaders, input, headersPromise, responsePromise, statusPromise, trailersPromise); + } + serverStreaming(method, input, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise + .then(delay(this.responseDelay, options.abort)) + .catch(() => { + }) + .then(() => this.streamResponses(method, outputStream, options.abort)) + .then(delay(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise + .then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise + .then(() => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = { single: input }; + return new server_streaming_call_1.ServerStreamingCall(method, requestHeaders, input, headersPromise, outputStream, statusPromise, trailersPromise); + } + clientStreaming(method, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), responsePromise = headersPromise + .catch(_ => { + }) + .then(delay(this.responseDelay, options.abort)) + .then(_ => this.promiseSingleResponse(method)), statusPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseStatus()), trailersPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = new TestInputStream(this.data, options.abort); + return new client_streaming_call_1.ClientStreamingCall(method, requestHeaders, this.lastInput, headersPromise, responsePromise, statusPromise, trailersPromise); + } + duplex(method, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise + .then(delay(this.responseDelay, options.abort)) + .catch(() => { + }) + .then(() => this.streamResponses(method, outputStream, options.abort)) + .then(delay(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise + .then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise + .then(() => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = new TestInputStream(this.data, options.abort); + return new duplex_streaming_call_1.DuplexStreamingCall(method, requestHeaders, this.lastInput, headersPromise, outputStream, statusPromise, trailersPromise); + } +} +exports.TestTransport = TestTransport; +TestTransport.defaultHeaders = { + responseHeader: "test" +}; +TestTransport.defaultStatus = { + code: "OK", detail: "all good" +}; +TestTransport.defaultTrailers = { + responseTrailer: "test" +}; +function delay(ms, abort) { + return (v) => new Promise((resolve, reject) => { + if (abort === null || abort === void 0 ? void 0 : abort.aborted) { + reject(new rpc_error_1.RpcError("user cancel", "CANCELLED")); + } + else { + const id = setTimeout(() => resolve(v), ms); + if (abort) { + abort.addEventListener("abort", ev => { + clearTimeout(id); + reject(new rpc_error_1.RpcError("user cancel", "CANCELLED")); + }); + } + } + }); +} +class TestInputStream { + constructor(data, abort) { + this._completed = false; + this._sent = []; + this.data = data; + this.abort = abort; + } + get sent() { + return this._sent; + } + get completed() { + return this._completed; + } + send(message) { + if (this.data.inputMessage instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.inputMessage); + } + const delayMs = this.data.inputMessage === undefined + ? 10 + : this.data.inputMessage; + return Promise.resolve(undefined) + .then(() => { + this._sent.push(message); + }) + .then(delay(delayMs, this.abort)); + } + complete() { + if (this.data.inputComplete instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.inputComplete); + } + const delayMs = this.data.inputComplete === undefined + ? 10 + : this.data.inputComplete; + return Promise.resolve(undefined) + .then(() => { + this._completed = true; + }) + .then(delay(delayMs, this.abort)); + } +} + + +/***/ }), + +/***/ 164: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.UnaryCall = void 0; +/** + * A unary RPC call. Unary means there is exactly one input message and + * exactly one output message unless an error occurred. + */ +class UnaryCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.request = request; + this.headers = headers; + this.response = response; + this.status = status; + this.trailers = trailers; + } + /** + * If you are only interested in the final outcome of this call, + * you can await it to receive a `FinishedUnaryCall`. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, response, status, trailers] = yield Promise.all([this.headers, this.response, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + request: this.request, + headers, + response, + status, + trailers + }; + }); + } +} +exports.UnaryCall = UnaryCall; + + +/***/ }), + +/***/ 4253: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.assertFloat32 = exports.assertUInt32 = exports.assertInt32 = exports.assertNever = exports.assert = void 0; +/** + * assert that condition is true or throw error (with message) + */ +function assert(condition, msg) { + if (!condition) { + throw new Error(msg); + } +} +exports.assert = assert; +/** + * assert that value cannot exist = type `never`. throw runtime error if it does. + */ +function assertNever(value, msg) { + throw new Error(msg !== null && msg !== void 0 ? msg : 'Unexpected object: ' + value); +} +exports.assertNever = assertNever; +const FLOAT32_MAX = 3.4028234663852886e+38, FLOAT32_MIN = -3.4028234663852886e+38, UINT32_MAX = 0xFFFFFFFF, INT32_MAX = 0X7FFFFFFF, INT32_MIN = -0X80000000; +function assertInt32(arg) { + if (typeof arg !== "number") + throw new Error('invalid int 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN) + throw new Error('invalid int 32: ' + arg); +} +exports.assertInt32 = assertInt32; +function assertUInt32(arg) { + if (typeof arg !== "number") + throw new Error('invalid uint 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0) + throw new Error('invalid uint 32: ' + arg); +} +exports.assertUInt32 = assertUInt32; +function assertFloat32(arg) { + if (typeof arg !== "number") + throw new Error('invalid float 32: ' + typeof arg); + if (!Number.isFinite(arg)) + return; + if (arg > FLOAT32_MAX || arg < FLOAT32_MIN) + throw new Error('invalid float 32: ' + arg); +} +exports.assertFloat32 = assertFloat32; + + +/***/ }), + +/***/ 196: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.base64encode = exports.base64decode = void 0; +// lookup table from base64 character to byte +let encTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(''); +// lookup table from base64 character *code* to byte because lookup by number is fast +let decTable = []; +for (let i = 0; i < encTable.length; i++) + decTable[encTable[i].charCodeAt(0)] = i; +// support base64url variants +decTable["-".charCodeAt(0)] = encTable.indexOf("+"); +decTable["_".charCodeAt(0)] = encTable.indexOf("/"); +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +function base64decode(base64Str) { + // estimate byte size, not accounting for inner padding and whitespace + let es = base64Str.length * 3 / 4; + // if (es % 3 !== 0) + // throw new Error('invalid base64 string'); + if (base64Str[base64Str.length - 2] == '=') + es -= 2; + else if (base64Str[base64Str.length - 1] == '=') + es -= 1; + let bytes = new Uint8Array(es), bytePos = 0, // position in byte array + groupPos = 0, // position in base64 group + b, // current byte + p = 0 // previous byte + ; + for (let i = 0; i < base64Str.length; i++) { + b = decTable[base64Str.charCodeAt(i)]; + if (b === undefined) { + // noinspection FallThroughInSwitchStatementJS + switch (base64Str[i]) { + case '=': + groupPos = 0; // reset state when padding found + case '\n': + case '\r': + case '\t': + case ' ': + continue; // skip white-space, and padding + default: + throw Error(`invalid base64 string.`); + } + } + switch (groupPos) { + case 0: + p = b; + groupPos = 1; + break; + case 1: + bytes[bytePos++] = p << 2 | (b & 48) >> 4; + p = b; + groupPos = 2; + break; + case 2: + bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2; + p = b; + groupPos = 3; + break; + case 3: + bytes[bytePos++] = (p & 3) << 6 | b; + groupPos = 0; + break; + } + } + if (groupPos == 1) + throw Error(`invalid base64 string.`); + return bytes.subarray(0, bytePos); +} +exports.base64decode = base64decode; +/** + * Encodes a byte array to a base64 string. + * Adds padding at the end. + * Does not insert newlines. + */ +function base64encode(bytes) { + let base64 = '', groupPos = 0, // position in base64 group + b, // current byte + p = 0; // carry over from previous byte + for (let i = 0; i < bytes.length; i++) { + b = bytes[i]; + switch (groupPos) { + case 0: + base64 += encTable[b >> 2]; + p = (b & 3) << 4; + groupPos = 1; + break; + case 1: + base64 += encTable[p | b >> 4]; + p = (b & 15) << 2; + groupPos = 2; + break; + case 2: + base64 += encTable[p | b >> 6]; + base64 += encTable[b & 63]; + groupPos = 0; + break; + } + } + // padding required? + if (groupPos) { + base64 += encTable[p]; + base64 += '='; + if (groupPos == 1) + base64 += '='; + } + return base64; +} +exports.base64encode = base64encode; + + +/***/ }), + +/***/ 4921: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.WireType = exports.mergeBinaryOptions = exports.UnknownFieldHandler = void 0; +/** + * This handler implements the default behaviour for unknown fields. + * When reading data, unknown fields are stored on the message, in a + * symbol property. + * When writing data, the symbol property is queried and unknown fields + * are serialized into the output again. + */ +var UnknownFieldHandler; +(function (UnknownFieldHandler) { + /** + * The symbol used to store unknown fields for a message. + * The property must conform to `UnknownFieldContainer`. + */ + UnknownFieldHandler.symbol = Symbol.for("protobuf-ts/unknown"); + /** + * Store an unknown field during binary read directly on the message. + * This method is compatible with `BinaryReadOptions.readUnknownField`. + */ + UnknownFieldHandler.onRead = (typeName, message, fieldNo, wireType, data) => { + let container = is(message) ? message[UnknownFieldHandler.symbol] : message[UnknownFieldHandler.symbol] = []; + container.push({ no: fieldNo, wireType, data }); + }; + /** + * Write unknown fields stored for the message to the writer. + * This method is compatible with `BinaryWriteOptions.writeUnknownFields`. + */ + UnknownFieldHandler.onWrite = (typeName, message, writer) => { + for (let { no, wireType, data } of UnknownFieldHandler.list(message)) + writer.tag(no, wireType).raw(data); + }; + /** + * List unknown fields stored for the message. + * Note that there may be multiples fields with the same number. + */ + UnknownFieldHandler.list = (message, fieldNo) => { + if (is(message)) { + let all = message[UnknownFieldHandler.symbol]; + return fieldNo ? all.filter(uf => uf.no == fieldNo) : all; + } + return []; + }; + /** + * Returns the last unknown field by field number. + */ + UnknownFieldHandler.last = (message, fieldNo) => UnknownFieldHandler.list(message, fieldNo).slice(-1)[0]; + const is = (message) => message && Array.isArray(message[UnknownFieldHandler.symbol]); +})(UnknownFieldHandler = exports.UnknownFieldHandler || (exports.UnknownFieldHandler = {})); +/** + * Merges binary write or read options. Later values override earlier values. + */ +function mergeBinaryOptions(a, b) { + return Object.assign(Object.assign({}, a), b); +} +exports.mergeBinaryOptions = mergeBinaryOptions; +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +var WireType; +(function (WireType) { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + WireType[WireType["Varint"] = 0] = "Varint"; + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + WireType[WireType["Bit64"] = 1] = "Bit64"; + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited"; + /** + * Used for groups + * @deprecated + */ + WireType[WireType["StartGroup"] = 3] = "StartGroup"; + /** + * Used for groups + * @deprecated + */ + WireType[WireType["EndGroup"] = 4] = "EndGroup"; + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + WireType[WireType["Bit32"] = 5] = "Bit32"; +})(WireType = exports.WireType || (exports.WireType = {})); + + +/***/ }), + +/***/ 5210: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BinaryReader = exports.binaryReadOptions = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const pb_long_1 = __nccwpck_require__(7777); +const goog_varint_1 = __nccwpck_require__(433); +const defaultsRead = { + readUnknownField: true, + readerFactory: bytes => new BinaryReader(bytes), +}; +/** + * Make options for reading binary data form partial options. + */ +function binaryReadOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead; +} +exports.binaryReadOptions = binaryReadOptions; +class BinaryReader { + constructor(buf, textDecoder) { + this.varint64 = goog_varint_1.varint64read; // dirty cast for `this` + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + this.uint32 = goog_varint_1.varint32read; // dirty cast for `this` and access to protected `buf` + this.buf = buf; + this.len = buf.length; + this.pos = 0; + this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); + this.textDecoder = textDecoder !== null && textDecoder !== void 0 ? textDecoder : new TextDecoder("utf-8", { + fatal: true, + ignoreBOM: true, + }); + } + /** + * Reads a tag - field number and wire type. + */ + tag() { + let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7; + if (fieldNo <= 0 || wireType < 0 || wireType > 5) + throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType); + return [fieldNo, wireType]; + } + /** + * Skip one element on the wire and return the skipped data. + * Supports WireType.StartGroup since v2.0.0-alpha.23. + */ + skip(wireType) { + let start = this.pos; + // noinspection FallThroughInSwitchStatementJS + switch (wireType) { + case binary_format_contract_1.WireType.Varint: + while (this.buf[this.pos++] & 0x80) { + // ignore + } + break; + case binary_format_contract_1.WireType.Bit64: + this.pos += 4; + case binary_format_contract_1.WireType.Bit32: + this.pos += 4; + break; + case binary_format_contract_1.WireType.LengthDelimited: + let len = this.uint32(); + this.pos += len; + break; + case binary_format_contract_1.WireType.StartGroup: + // From descriptor.proto: Group type is deprecated, not supported in proto3. + // But we must still be able to parse and treat as unknown. + let t; + while ((t = this.tag()[1]) !== binary_format_contract_1.WireType.EndGroup) { + this.skip(t); + } + break; + default: + throw new Error("cant skip wire type " + wireType); + } + this.assertBounds(); + return this.buf.subarray(start, this.pos); + } + /** + * Throws error if position in byte array is out of range. + */ + assertBounds() { + if (this.pos > this.len) + throw new RangeError("premature EOF"); + } + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32() { + return this.uint32() | 0; + } + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32() { + let zze = this.uint32(); + // decode zigzag + return (zze >>> 1) ^ -(zze & 1); + } + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64() { + return new pb_long_1.PbLong(...this.varint64()); + } + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64() { + return new pb_long_1.PbULong(...this.varint64()); + } + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64() { + let [lo, hi] = this.varint64(); + // decode zig zag + let s = -(lo & 1); + lo = ((lo >>> 1 | (hi & 1) << 31) ^ s); + hi = (hi >>> 1 ^ s); + return new pb_long_1.PbLong(lo, hi); + } + /** + * Read a `bool` field, a variant. + */ + bool() { + let [lo, hi] = this.varint64(); + return lo !== 0 || hi !== 0; + } + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32() { + return this.view.getUint32((this.pos += 4) - 4, true); + } + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32() { + return this.view.getInt32((this.pos += 4) - 4, true); + } + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64() { + return new pb_long_1.PbULong(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64() { + return new pb_long_1.PbLong(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `float` field, 32-bit floating point number. + */ + float() { + return this.view.getFloat32((this.pos += 4) - 4, true); + } + /** + * Read a `double` field, a 64-bit floating point number. + */ + double() { + return this.view.getFloat64((this.pos += 8) - 8, true); + } + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes() { + let len = this.uint32(); + let start = this.pos; + this.pos += len; + this.assertBounds(); + return this.buf.subarray(start, start + len); + } + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string() { + return this.textDecoder.decode(this.bytes()); + } +} +exports.BinaryReader = BinaryReader; + + +/***/ }), + +/***/ 4354: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BinaryWriter = exports.binaryWriteOptions = void 0; +const pb_long_1 = __nccwpck_require__(7777); +const goog_varint_1 = __nccwpck_require__(433); +const assert_1 = __nccwpck_require__(4253); +const defaultsWrite = { + writeUnknownFields: true, + writerFactory: () => new BinaryWriter(), +}; +/** + * Make options for writing binary data form partial options. + */ +function binaryWriteOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite; +} +exports.binaryWriteOptions = binaryWriteOptions; +class BinaryWriter { + constructor(textEncoder) { + /** + * Previous fork states. + */ + this.stack = []; + this.textEncoder = textEncoder !== null && textEncoder !== void 0 ? textEncoder : new TextEncoder(); + this.chunks = []; + this.buf = []; + } + /** + * Return all bytes written and reset this writer. + */ + finish() { + this.chunks.push(new Uint8Array(this.buf)); // flush the buffer + let len = 0; + for (let i = 0; i < this.chunks.length; i++) + len += this.chunks[i].length; + let bytes = new Uint8Array(len); + let offset = 0; + for (let i = 0; i < this.chunks.length; i++) { + bytes.set(this.chunks[i], offset); + offset += this.chunks[i].length; + } + this.chunks = []; + return bytes; + } + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork() { + this.stack.push({ chunks: this.chunks, buf: this.buf }); + this.chunks = []; + this.buf = []; + return this; + } + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join() { + // get chunk of fork + let chunk = this.finish(); + // restore previous state + let prev = this.stack.pop(); + if (!prev) + throw new Error('invalid state, fork stack empty'); + this.chunks = prev.chunks; + this.buf = prev.buf; + // write length of chunk as varint + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo, type) { + return this.uint32((fieldNo << 3 | type) >>> 0); + } + /** + * Write a chunk of raw bytes. + */ + raw(chunk) { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); + this.buf = []; + } + this.chunks.push(chunk); + return this; + } + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value) { + assert_1.assertUInt32(value); + // write value as varint 32, inlined for speed + while (value > 0x7f) { + this.buf.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + this.buf.push(value); + return this; + } + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value) { + assert_1.assertInt32(value); + goog_varint_1.varint32write(value, this.buf); + return this; + } + /** + * Write a `bool` value, a variant. + */ + bool(value) { + this.buf.push(value ? 1 : 0); + return this; + } + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value) { + this.uint32(value.byteLength); // write length of chunk as varint + return this.raw(value); + } + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value) { + let chunk = this.textEncoder.encode(value); + this.uint32(chunk.byteLength); // write length of chunk as varint + return this.raw(chunk); + } + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value) { + assert_1.assertFloat32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setFloat32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value) { + let chunk = new Uint8Array(8); + new DataView(chunk.buffer).setFloat64(0, value, true); + return this.raw(chunk); + } + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value) { + assert_1.assertUInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setUint32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value) { + assert_1.assertInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setInt32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value) { + assert_1.assertInt32(value); + // zigzag encode + value = ((value << 1) ^ (value >> 31)) >>> 0; + goog_varint_1.varint32write(value, this.buf); + return this; + } + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value) { + let chunk = new Uint8Array(8); + let view = new DataView(chunk.buffer); + let long = pb_long_1.PbLong.from(value); + view.setInt32(0, long.lo, true); + view.setInt32(4, long.hi, true); + return this.raw(chunk); + } + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value) { + let chunk = new Uint8Array(8); + let view = new DataView(chunk.buffer); + let long = pb_long_1.PbULong.from(value); + view.setInt32(0, long.lo, true); + view.setInt32(4, long.hi, true); + return this.raw(chunk); + } + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value) { + let long = pb_long_1.PbLong.from(value); + goog_varint_1.varint64write(long.lo, long.hi, this.buf); + return this; + } + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value) { + let long = pb_long_1.PbLong.from(value), + // zigzag encode + sign = long.hi >> 31, lo = (long.lo << 1) ^ sign, hi = ((long.hi << 1) | (long.lo >>> 31)) ^ sign; + goog_varint_1.varint64write(lo, hi, this.buf); + return this; + } + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value) { + let long = pb_long_1.PbULong.from(value); + goog_varint_1.varint64write(long.lo, long.hi, this.buf); + return this; + } +} +exports.BinaryWriter = BinaryWriter; + + +/***/ }), + +/***/ 85: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.listEnumNumbers = exports.listEnumNames = exports.listEnumValues = exports.isEnumObject = void 0; +/** + * Is this a lookup object generated by Typescript, for a Typescript enum + * generated by protobuf-ts? + * + * - No `const enum` (enum must not be inlined, we need reverse mapping). + * - No string enum (we need int32 for protobuf). + * - Must have a value for 0 (otherwise, we would need to support custom default values). + */ +function isEnumObject(arg) { + if (typeof arg != 'object' || arg === null) { + return false; + } + if (!arg.hasOwnProperty(0)) { + return false; + } + for (let k of Object.keys(arg)) { + let num = parseInt(k); + if (!Number.isNaN(num)) { + // is there a name for the number? + let nam = arg[num]; + if (nam === undefined) + return false; + // does the name resolve back to the number? + if (arg[nam] !== num) + return false; + } + else { + // is there a number for the name? + let num = arg[k]; + if (num === undefined) + return false; + // is it a string enum? + if (typeof num !== 'number') + return false; + // do we know the number? + if (arg[num] === undefined) + return false; + } + } + return true; +} +exports.isEnumObject = isEnumObject; +/** + * Lists all values of a Typescript enum, as an array of objects with a "name" + * property and a "number" property. + * + * Note that it is possible that a number appears more than once, because it is + * possible to have aliases in an enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumValues(enumObject) { + if (!isEnumObject(enumObject)) + throw new Error("not a typescript enum object"); + let values = []; + for (let [name, number] of Object.entries(enumObject)) + if (typeof number == "number") + values.push({ name, number }); + return values; +} +exports.listEnumValues = listEnumValues; +/** + * Lists the names of a Typescript enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumNames(enumObject) { + return listEnumValues(enumObject).map(val => val.name); +} +exports.listEnumNames = listEnumNames; +/** + * Lists the numbers of a Typescript enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumNumbers(enumObject) { + return listEnumValues(enumObject) + .map(val => val.number) + .filter((num, index, arr) => arr.indexOf(num) == index); +} +exports.listEnumNumbers = listEnumNumbers; + + +/***/ }), + +/***/ 433: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// Copyright 2008 Google Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Code generated by the Protocol Buffer compiler is owned by the owner +// of the input file used when generating it. This code is not +// standalone and requires a support library to be linked with it. This +// support library is itself covered by the above license. +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.varint32read = exports.varint32write = exports.int64toString = exports.int64fromString = exports.varint64write = exports.varint64read = void 0; +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [0]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +function varint64read() { + let lowBits = 0; + let highBits = 0; + for (let shift = 0; shift < 28; shift += 7) { + let b = this.buf[this.pos++]; + lowBits |= (b & 0x7F) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + let middleByte = this.buf[this.pos++]; + // last four bits of the first 32 bit number + lowBits |= (middleByte & 0x0F) << 28; + // 3 upper bits are part of the next 32 bit number + highBits = (middleByte & 0x70) >> 4; + if ((middleByte & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + for (let shift = 3; shift <= 31; shift += 7) { + let b = this.buf[this.pos++]; + highBits |= (b & 0x7F) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + throw new Error('invalid varint'); +} +exports.varint64read = varint64read; +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +function varint64write(lo, hi, bytes) { + for (let i = 0; i < 28; i = i + 7) { + const shift = lo >>> i; + const hasNext = !((shift >>> 7) == 0 && hi == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xFF; + bytes.push(byte); + if (!hasNext) { + return; + } + } + const splitBits = ((lo >>> 28) & 0x0F) | ((hi & 0x07) << 4); + const hasMoreBits = !((hi >> 3) == 0); + bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xFF); + if (!hasMoreBits) { + return; + } + for (let i = 3; i < 31; i = i + 7) { + const shift = hi >>> i; + const hasNext = !((shift >>> 7) == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xFF; + bytes.push(byte); + if (!hasNext) { + return; + } + } + bytes.push((hi >>> 31) & 0x01); +} +exports.varint64write = varint64write; +// constants for binary math +const TWO_PWR_32_DBL = (1 << 16) * (1 << 16); +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Returns tuple: + * [0]: minus sign? + * [1]: low bits + * [2]: high bits + * + * Copyright 2008 Google Inc. + */ +function int64fromString(dec) { + // Check for minus sign. + let minus = dec[0] == '-'; + if (minus) + dec = dec.slice(1); + // Work 6 decimal digits at a time, acting like we're converting base 1e6 + // digits to binary. This is safe to do with floating point math because + // Number.isSafeInteger(ALL_32_BITS * 1e6) == true. + const base = 1e6; + let lowBits = 0; + let highBits = 0; + function add1e6digit(begin, end) { + // Note: Number('') is 0. + const digit1e6 = Number(dec.slice(begin, end)); + highBits *= base; + lowBits = lowBits * base + digit1e6; + // Carry bits from lowBits to highBits + if (lowBits >= TWO_PWR_32_DBL) { + highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0); + lowBits = lowBits % TWO_PWR_32_DBL; + } + } + add1e6digit(-24, -18); + add1e6digit(-18, -12); + add1e6digit(-12, -6); + add1e6digit(-6); + return [minus, lowBits, highBits]; +} +exports.int64fromString = int64fromString; +/** + * Format 64 bit integer value (as two JS numbers) to decimal string. + * + * Copyright 2008 Google Inc. + */ +function int64toString(bitsLow, bitsHigh) { + // Skip the expensive conversion if the number is small enough to use the + // built-in conversions. + if ((bitsHigh >>> 0) <= 0x1FFFFF) { + return '' + (TWO_PWR_32_DBL * bitsHigh + (bitsLow >>> 0)); + } + // What this code is doing is essentially converting the input number from + // base-2 to base-1e7, which allows us to represent the 64-bit range with + // only 3 (very large) digits. Those digits are then trivial to convert to + // a base-10 string. + // The magic numbers used here are - + // 2^24 = 16777216 = (1,6777216) in base-1e7. + // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7. + // Split 32:32 representation into 16:24:24 representation so our + // intermediate digits don't overflow. + let low = bitsLow & 0xFFFFFF; + let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xFFFFFF; + let high = (bitsHigh >> 16) & 0xFFFF; + // Assemble our three base-1e7 digits, ignoring carries. The maximum + // value in a digit at this step is representable as a 48-bit integer, which + // can be stored in a 64-bit floating point number. + let digitA = low + (mid * 6777216) + (high * 6710656); + let digitB = mid + (high * 8147497); + let digitC = (high * 2); + // Apply carries from A to B and from B to C. + let base = 10000000; + if (digitA >= base) { + digitB += Math.floor(digitA / base); + digitA %= base; + } + if (digitB >= base) { + digitC += Math.floor(digitB / base); + digitB %= base; + } + // Convert base-1e7 digits to base-10, with optional leading zeroes. + function decimalFrom1e7(digit1e7, needLeadingZeros) { + let partial = digit1e7 ? String(digit1e7) : ''; + if (needLeadingZeros) { + return '0000000'.slice(partial.length) + partial; + } + return partial; + } + return decimalFrom1e7(digitC, /*needLeadingZeros=*/ 0) + + decimalFrom1e7(digitB, /*needLeadingZeros=*/ digitC) + + // If the final 1e7 digit didn't need leading zeros, we would have + // returned via the trivial code path at the top. + decimalFrom1e7(digitA, /*needLeadingZeros=*/ 1); +} +exports.int64toString = int64toString; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +function varint32write(value, bytes) { + if (value >= 0) { + // write value as varint 32 + while (value > 0x7f) { + bytes.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + bytes.push(value); + } + else { + for (let i = 0; i < 9; i++) { + bytes.push(value & 127 | 128); + value = value >> 7; + } + bytes.push(1); + } +} +exports.varint32write = varint32write; +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +function varint32read() { + let b = this.buf[this.pos++]; + let result = b & 0x7F; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 7; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 14; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 21; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + // Extract only last 4 bits + b = this.buf[this.pos++]; + result |= (b & 0x0F) << 28; + for (let readBytes = 5; ((b & 0x80) !== 0) && readBytes < 10; readBytes++) + b = this.buf[this.pos++]; + if ((b & 0x80) != 0) + throw new Error('invalid varint'); + this.assertBounds(); + // Result can have 32 bits, convert it to unsigned + return result >>> 0; +} +exports.varint32read = varint32read; + + +/***/ }), + +/***/ 4061: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +// Public API of the protobuf-ts runtime. +// Note: we do not use `export * from ...` to help tree shakers, +// webpack verbose output hints that this should be useful +Object.defineProperty(exports, "__esModule", ({ value: true })); +// Convenience JSON typings and corresponding type guards +var json_typings_1 = __nccwpck_require__(661); +Object.defineProperty(exports, "typeofJsonValue", ({ enumerable: true, get: function () { return json_typings_1.typeofJsonValue; } })); +Object.defineProperty(exports, "isJsonObject", ({ enumerable: true, get: function () { return json_typings_1.isJsonObject; } })); +// Base 64 encoding +var base64_1 = __nccwpck_require__(196); +Object.defineProperty(exports, "base64decode", ({ enumerable: true, get: function () { return base64_1.base64decode; } })); +Object.defineProperty(exports, "base64encode", ({ enumerable: true, get: function () { return base64_1.base64encode; } })); +// UTF8 encoding +var protobufjs_utf8_1 = __nccwpck_require__(5290); +Object.defineProperty(exports, "utf8read", ({ enumerable: true, get: function () { return protobufjs_utf8_1.utf8read; } })); +// Binary format contracts, options for reading and writing, for example +var binary_format_contract_1 = __nccwpck_require__(4921); +Object.defineProperty(exports, "WireType", ({ enumerable: true, get: function () { return binary_format_contract_1.WireType; } })); +Object.defineProperty(exports, "mergeBinaryOptions", ({ enumerable: true, get: function () { return binary_format_contract_1.mergeBinaryOptions; } })); +Object.defineProperty(exports, "UnknownFieldHandler", ({ enumerable: true, get: function () { return binary_format_contract_1.UnknownFieldHandler; } })); +// Standard IBinaryReader implementation +var binary_reader_1 = __nccwpck_require__(5210); +Object.defineProperty(exports, "BinaryReader", ({ enumerable: true, get: function () { return binary_reader_1.BinaryReader; } })); +Object.defineProperty(exports, "binaryReadOptions", ({ enumerable: true, get: function () { return binary_reader_1.binaryReadOptions; } })); +// Standard IBinaryWriter implementation +var binary_writer_1 = __nccwpck_require__(4354); +Object.defineProperty(exports, "BinaryWriter", ({ enumerable: true, get: function () { return binary_writer_1.BinaryWriter; } })); +Object.defineProperty(exports, "binaryWriteOptions", ({ enumerable: true, get: function () { return binary_writer_1.binaryWriteOptions; } })); +// Int64 and UInt64 implementations required for the binary format +var pb_long_1 = __nccwpck_require__(7777); +Object.defineProperty(exports, "PbLong", ({ enumerable: true, get: function () { return pb_long_1.PbLong; } })); +Object.defineProperty(exports, "PbULong", ({ enumerable: true, get: function () { return pb_long_1.PbULong; } })); +// JSON format contracts, options for reading and writing, for example +var json_format_contract_1 = __nccwpck_require__(8139); +Object.defineProperty(exports, "jsonReadOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonReadOptions; } })); +Object.defineProperty(exports, "jsonWriteOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonWriteOptions; } })); +Object.defineProperty(exports, "mergeJsonOptions", ({ enumerable: true, get: function () { return json_format_contract_1.mergeJsonOptions; } })); +// Message type contract +var message_type_contract_1 = __nccwpck_require__(1682); +Object.defineProperty(exports, "MESSAGE_TYPE", ({ enumerable: true, get: function () { return message_type_contract_1.MESSAGE_TYPE; } })); +// Message type implementation via reflection +var message_type_1 = __nccwpck_require__(3664); +Object.defineProperty(exports, "MessageType", ({ enumerable: true, get: function () { return message_type_1.MessageType; } })); +// Reflection info, generated by the plugin, exposed to the user, used by reflection ops +var reflection_info_1 = __nccwpck_require__(1370); +Object.defineProperty(exports, "ScalarType", ({ enumerable: true, get: function () { return reflection_info_1.ScalarType; } })); +Object.defineProperty(exports, "LongType", ({ enumerable: true, get: function () { return reflection_info_1.LongType; } })); +Object.defineProperty(exports, "RepeatType", ({ enumerable: true, get: function () { return reflection_info_1.RepeatType; } })); +Object.defineProperty(exports, "normalizeFieldInfo", ({ enumerable: true, get: function () { return reflection_info_1.normalizeFieldInfo; } })); +Object.defineProperty(exports, "readFieldOptions", ({ enumerable: true, get: function () { return reflection_info_1.readFieldOptions; } })); +Object.defineProperty(exports, "readFieldOption", ({ enumerable: true, get: function () { return reflection_info_1.readFieldOption; } })); +Object.defineProperty(exports, "readMessageOption", ({ enumerable: true, get: function () { return reflection_info_1.readMessageOption; } })); +// Message operations via reflection +var reflection_type_check_1 = __nccwpck_require__(903); +Object.defineProperty(exports, "ReflectionTypeCheck", ({ enumerable: true, get: function () { return reflection_type_check_1.ReflectionTypeCheck; } })); +var reflection_create_1 = __nccwpck_require__(390); +Object.defineProperty(exports, "reflectionCreate", ({ enumerable: true, get: function () { return reflection_create_1.reflectionCreate; } })); +var reflection_scalar_default_1 = __nccwpck_require__(4863); +Object.defineProperty(exports, "reflectionScalarDefault", ({ enumerable: true, get: function () { return reflection_scalar_default_1.reflectionScalarDefault; } })); +var reflection_merge_partial_1 = __nccwpck_require__(7869); +Object.defineProperty(exports, "reflectionMergePartial", ({ enumerable: true, get: function () { return reflection_merge_partial_1.reflectionMergePartial; } })); +var reflection_equals_1 = __nccwpck_require__(9473); +Object.defineProperty(exports, "reflectionEquals", ({ enumerable: true, get: function () { return reflection_equals_1.reflectionEquals; } })); +var reflection_binary_reader_1 = __nccwpck_require__(1593); +Object.defineProperty(exports, "ReflectionBinaryReader", ({ enumerable: true, get: function () { return reflection_binary_reader_1.ReflectionBinaryReader; } })); +var reflection_binary_writer_1 = __nccwpck_require__(7170); +Object.defineProperty(exports, "ReflectionBinaryWriter", ({ enumerable: true, get: function () { return reflection_binary_writer_1.ReflectionBinaryWriter; } })); +var reflection_json_reader_1 = __nccwpck_require__(229); +Object.defineProperty(exports, "ReflectionJsonReader", ({ enumerable: true, get: function () { return reflection_json_reader_1.ReflectionJsonReader; } })); +var reflection_json_writer_1 = __nccwpck_require__(8980); +Object.defineProperty(exports, "ReflectionJsonWriter", ({ enumerable: true, get: function () { return reflection_json_writer_1.ReflectionJsonWriter; } })); +var reflection_contains_message_type_1 = __nccwpck_require__(7317); +Object.defineProperty(exports, "containsMessageType", ({ enumerable: true, get: function () { return reflection_contains_message_type_1.containsMessageType; } })); +// Oneof helpers +var oneof_1 = __nccwpck_require__(8531); +Object.defineProperty(exports, "isOneofGroup", ({ enumerable: true, get: function () { return oneof_1.isOneofGroup; } })); +Object.defineProperty(exports, "setOneofValue", ({ enumerable: true, get: function () { return oneof_1.setOneofValue; } })); +Object.defineProperty(exports, "getOneofValue", ({ enumerable: true, get: function () { return oneof_1.getOneofValue; } })); +Object.defineProperty(exports, "clearOneofValue", ({ enumerable: true, get: function () { return oneof_1.clearOneofValue; } })); +Object.defineProperty(exports, "getSelectedOneofValue", ({ enumerable: true, get: function () { return oneof_1.getSelectedOneofValue; } })); +// Enum object type guard and reflection util, may be interesting to the user. +var enum_object_1 = __nccwpck_require__(85); +Object.defineProperty(exports, "listEnumValues", ({ enumerable: true, get: function () { return enum_object_1.listEnumValues; } })); +Object.defineProperty(exports, "listEnumNames", ({ enumerable: true, get: function () { return enum_object_1.listEnumNames; } })); +Object.defineProperty(exports, "listEnumNumbers", ({ enumerable: true, get: function () { return enum_object_1.listEnumNumbers; } })); +Object.defineProperty(exports, "isEnumObject", ({ enumerable: true, get: function () { return enum_object_1.isEnumObject; } })); +// lowerCamelCase() is exported for plugin, rpc-runtime and other rpc packages +var lower_camel_case_1 = __nccwpck_require__(4772); +Object.defineProperty(exports, "lowerCamelCase", ({ enumerable: true, get: function () { return lower_camel_case_1.lowerCamelCase; } })); +// assertion functions are exported for plugin, may also be useful to user +var assert_1 = __nccwpck_require__(4253); +Object.defineProperty(exports, "assert", ({ enumerable: true, get: function () { return assert_1.assert; } })); +Object.defineProperty(exports, "assertNever", ({ enumerable: true, get: function () { return assert_1.assertNever; } })); +Object.defineProperty(exports, "assertInt32", ({ enumerable: true, get: function () { return assert_1.assertInt32; } })); +Object.defineProperty(exports, "assertUInt32", ({ enumerable: true, get: function () { return assert_1.assertUInt32; } })); +Object.defineProperty(exports, "assertFloat32", ({ enumerable: true, get: function () { return assert_1.assertFloat32; } })); + + +/***/ }), + +/***/ 8139: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.mergeJsonOptions = exports.jsonWriteOptions = exports.jsonReadOptions = void 0; +const defaultsWrite = { + emitDefaultValues: false, + enumAsInteger: false, + useProtoFieldName: false, + prettySpaces: 0, +}, defaultsRead = { + ignoreUnknownFields: false, +}; +/** + * Make options for reading JSON data from partial options. + */ +function jsonReadOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead; +} +exports.jsonReadOptions = jsonReadOptions; +/** + * Make options for writing JSON data from partial options. + */ +function jsonWriteOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite; +} +exports.jsonWriteOptions = jsonWriteOptions; +/** + * Merges JSON write or read options. Later values override earlier values. Type registries are merged. + */ +function mergeJsonOptions(a, b) { + var _a, _b; + let c = Object.assign(Object.assign({}, a), b); + c.typeRegistry = [...((_a = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a !== void 0 ? _a : []), ...((_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : [])]; + return c; +} +exports.mergeJsonOptions = mergeJsonOptions; + + +/***/ }), + +/***/ 661: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isJsonObject = exports.typeofJsonValue = void 0; +/** + * Get the type of a JSON value. + * Distinguishes between array, null and object. + */ +function typeofJsonValue(value) { + let t = typeof value; + if (t == "object") { + if (Array.isArray(value)) + return "array"; + if (value === null) + return "null"; + } + return t; +} +exports.typeofJsonValue = typeofJsonValue; +/** + * Is this a JSON object (instead of an array or null)? + */ +function isJsonObject(value) { + return value !== null && typeof value == "object" && !Array.isArray(value); +} +exports.isJsonObject = isJsonObject; + + +/***/ }), + +/***/ 4772: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lowerCamelCase = void 0; +/** + * Converts snake_case to lowerCamelCase. + * + * Should behave like protoc: + * https://github.com/protocolbuffers/protobuf/blob/e8ae137c96444ea313485ed1118c5e43b2099cf1/src/google/protobuf/compiler/java/java_helpers.cc#L118 + */ +function lowerCamelCase(snakeCase) { + let capNext = false; + const sb = []; + for (let i = 0; i < snakeCase.length; i++) { + let next = snakeCase.charAt(i); + if (next == '_') { + capNext = true; + } + else if (/\d/.test(next)) { + sb.push(next); + capNext = true; + } + else if (capNext) { + sb.push(next.toUpperCase()); + capNext = false; + } + else if (i == 0) { + sb.push(next.toLowerCase()); + } + else { + sb.push(next); + } + } + return sb.join(''); +} +exports.lowerCamelCase = lowerCamelCase; + + +/***/ }), + +/***/ 1682: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MESSAGE_TYPE = void 0; +/** + * The symbol used as a key on message objects to store the message type. + * + * Note that this is an experimental feature - it is here to stay, but + * implementation details may change without notice. + */ +exports.MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type"); + + +/***/ }), + +/***/ 3664: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MessageType = void 0; +const message_type_contract_1 = __nccwpck_require__(1682); +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_type_check_1 = __nccwpck_require__(903); +const reflection_json_reader_1 = __nccwpck_require__(229); +const reflection_json_writer_1 = __nccwpck_require__(8980); +const reflection_binary_reader_1 = __nccwpck_require__(1593); +const reflection_binary_writer_1 = __nccwpck_require__(7170); +const reflection_create_1 = __nccwpck_require__(390); +const reflection_merge_partial_1 = __nccwpck_require__(7869); +const json_typings_1 = __nccwpck_require__(661); +const json_format_contract_1 = __nccwpck_require__(8139); +const reflection_equals_1 = __nccwpck_require__(9473); +const binary_writer_1 = __nccwpck_require__(4354); +const binary_reader_1 = __nccwpck_require__(5210); +const baseDescriptors = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({})); +/** + * This standard message type provides reflection-based + * operations to work with a message. + */ +class MessageType { + constructor(name, fields, options) { + this.defaultCheckDepth = 16; + this.typeName = name; + this.fields = fields.map(reflection_info_1.normalizeFieldInfo); + this.options = options !== null && options !== void 0 ? options : {}; + this.messagePrototype = Object.create(null, Object.assign(Object.assign({}, baseDescriptors), { [message_type_contract_1.MESSAGE_TYPE]: { value: this } })); + this.refTypeCheck = new reflection_type_check_1.ReflectionTypeCheck(this); + this.refJsonReader = new reflection_json_reader_1.ReflectionJsonReader(this); + this.refJsonWriter = new reflection_json_writer_1.ReflectionJsonWriter(this); + this.refBinReader = new reflection_binary_reader_1.ReflectionBinaryReader(this); + this.refBinWriter = new reflection_binary_writer_1.ReflectionBinaryWriter(this); + } + create(value) { + let message = reflection_create_1.reflectionCreate(this); + if (value !== undefined) { + reflection_merge_partial_1.reflectionMergePartial(this, message, value); + } + return message; + } + /** + * Clone the message. + * + * Unknown fields are discarded. + */ + clone(message) { + let copy = this.create(); + reflection_merge_partial_1.reflectionMergePartial(this, copy, message); + return copy; + } + /** + * Determines whether two message of the same type have the same field values. + * Checks for deep equality, traversing repeated fields, oneof groups, maps + * and messages recursively. + * Will also return true if both messages are `undefined`. + */ + equals(a, b) { + return reflection_equals_1.reflectionEquals(this, a, b); + } + /** + * Is the given value assignable to our message type + * and contains no [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)? + */ + is(arg, depth = this.defaultCheckDepth) { + return this.refTypeCheck.is(arg, depth, false); + } + /** + * Is the given value assignable to our message type, + * regardless of [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)? + */ + isAssignable(arg, depth = this.defaultCheckDepth) { + return this.refTypeCheck.is(arg, depth, true); + } + /** + * Copy partial data into the target message. + */ + mergePartial(target, source) { + reflection_merge_partial_1.reflectionMergePartial(this, target, source); + } + /** + * Create a new message from binary format. + */ + fromBinary(data, options) { + let opt = binary_reader_1.binaryReadOptions(options); + return this.internalBinaryRead(opt.readerFactory(data), data.byteLength, opt); + } + /** + * Read a new message from a JSON value. + */ + fromJson(json, options) { + return this.internalJsonRead(json, json_format_contract_1.jsonReadOptions(options)); + } + /** + * Read a new message from a JSON string. + * This is equivalent to `T.fromJson(JSON.parse(json))`. + */ + fromJsonString(json, options) { + let value = JSON.parse(json); + return this.fromJson(value, options); + } + /** + * Write the message to canonical JSON value. + */ + toJson(message, options) { + return this.internalJsonWrite(message, json_format_contract_1.jsonWriteOptions(options)); + } + /** + * Convert the message to canonical JSON string. + * This is equivalent to `JSON.stringify(T.toJson(t))` + */ + toJsonString(message, options) { + var _a; + let value = this.toJson(message, options); + return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0); + } + /** + * Write the message to binary format. + */ + toBinary(message, options) { + let opt = binary_writer_1.binaryWriteOptions(options); + return this.internalBinaryWrite(message, opt.writerFactory(), opt).finish(); + } + /** + * This is an internal method. If you just want to read a message from + * JSON, use `fromJson()` or `fromJsonString()`. + * + * Reads JSON value and merges the fields into the target + * according to protobuf rules. If the target is omitted, + * a new instance is created first. + */ + internalJsonRead(json, options, target) { + if (json !== null && typeof json == "object" && !Array.isArray(json)) { + let message = target !== null && target !== void 0 ? target : this.create(); + this.refJsonReader.read(json, message, options); + return message; + } + throw new Error(`Unable to parse message ${this.typeName} from JSON ${json_typings_1.typeofJsonValue(json)}.`); + } + /** + * This is an internal method. If you just want to write a message + * to JSON, use `toJson()` or `toJsonString(). + * + * Writes JSON value and returns it. + */ + internalJsonWrite(message, options) { + return this.refJsonWriter.write(message, options); + } + /** + * This is an internal method. If you just want to write a message + * in binary format, use `toBinary()`. + * + * Serializes the message in binary format and appends it to the given + * writer. Returns passed writer. + */ + internalBinaryWrite(message, writer, options) { + this.refBinWriter.write(message, writer, options); + return writer; + } + /** + * This is an internal method. If you just want to read a message from + * binary data, use `fromBinary()`. + * + * Reads data from binary format and merges the fields into + * the target according to protobuf rules. If the target is + * omitted, a new instance is created first. + */ + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(); + this.refBinReader.read(reader, message, options, length); + return message; + } +} +exports.MessageType = MessageType; + + +/***/ }), + +/***/ 8531: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getSelectedOneofValue = exports.clearOneofValue = exports.setUnknownOneofValue = exports.setOneofValue = exports.getOneofValue = exports.isOneofGroup = void 0; +/** + * Is the given value a valid oneof group? + * + * We represent protobuf `oneof` as algebraic data types (ADT) in generated + * code. But when working with messages of unknown type, the ADT does not + * help us. + * + * This type guard checks if the given object adheres to the ADT rules, which + * are as follows: + * + * 1) Must be an object. + * + * 2) Must have a "oneofKind" discriminator property. + * + * 3) If "oneofKind" is `undefined`, no member field is selected. The object + * must not have any other properties. + * + * 4) If "oneofKind" is a `string`, the member field with this name is + * selected. + * + * 5) If a member field is selected, the object must have a second property + * with this name. The property must not be `undefined`. + * + * 6) No extra properties are allowed. The object has either one property + * (no selection) or two properties (selection). + * + */ +function isOneofGroup(any) { + if (typeof any != 'object' || any === null || !any.hasOwnProperty('oneofKind')) { + return false; + } + switch (typeof any.oneofKind) { + case "string": + if (any[any.oneofKind] === undefined) + return false; + return Object.keys(any).length == 2; + case "undefined": + return Object.keys(any).length == 1; + default: + return false; + } +} +exports.isOneofGroup = isOneofGroup; +/** + * Returns the value of the given field in a oneof group. + */ +function getOneofValue(oneof, kind) { + return oneof[kind]; +} +exports.getOneofValue = getOneofValue; +function setOneofValue(oneof, kind, value) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = kind; + if (value !== undefined) { + oneof[kind] = value; + } +} +exports.setOneofValue = setOneofValue; +function setUnknownOneofValue(oneof, kind, value) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = kind; + if (value !== undefined && kind !== undefined) { + oneof[kind] = value; + } +} +exports.setUnknownOneofValue = setUnknownOneofValue; +/** + * Removes the selected field in a oneof group. + * + * Note that the recommended way to modify a oneof group is to set + * a new object: + * + * ```ts + * message.result = { oneofKind: undefined }; + * ``` + */ +function clearOneofValue(oneof) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = undefined; +} +exports.clearOneofValue = clearOneofValue; +/** + * Returns the selected value of the given oneof group. + * + * Not that the recommended way to access a oneof group is to check + * the "oneofKind" property and let TypeScript narrow down the union + * type for you: + * + * ```ts + * if (message.result.oneofKind === "error") { + * message.result.error; // string + * } + * ``` + * + * In the rare case you just need the value, and do not care about + * which protobuf field is selected, you can use this function + * for convenience. + */ +function getSelectedOneofValue(oneof) { + if (oneof.oneofKind === undefined) { + return undefined; + } + return oneof[oneof.oneofKind]; +} +exports.getSelectedOneofValue = getSelectedOneofValue; + + +/***/ }), + +/***/ 7777: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.PbLong = exports.PbULong = exports.detectBi = void 0; +const goog_varint_1 = __nccwpck_require__(433); +let BI; +function detectBi() { + const dv = new DataView(new ArrayBuffer(8)); + const ok = globalThis.BigInt !== undefined + && typeof dv.getBigInt64 === "function" + && typeof dv.getBigUint64 === "function" + && typeof dv.setBigInt64 === "function" + && typeof dv.setBigUint64 === "function"; + BI = ok ? { + MIN: BigInt("-9223372036854775808"), + MAX: BigInt("9223372036854775807"), + UMIN: BigInt("0"), + UMAX: BigInt("18446744073709551615"), + C: BigInt, + V: dv, + } : undefined; +} +exports.detectBi = detectBi; +detectBi(); +function assertBi(bi) { + if (!bi) + throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support"); +} +// used to validate from(string) input (when bigint is unavailable) +const RE_DECIMAL_STR = /^-?[0-9]+$/; +// constants for binary math +const TWO_PWR_32_DBL = 0x100000000; +const HALF_2_PWR_32 = 0x080000000; +// base class for PbLong and PbULong provides shared code +class SharedPbLong { + /** + * Create a new instance with the given bits. + */ + constructor(lo, hi) { + this.lo = lo | 0; + this.hi = hi | 0; + } + /** + * Is this instance equal to 0? + */ + isZero() { + return this.lo == 0 && this.hi == 0; + } + /** + * Convert to a native number. + */ + toNumber() { + let result = this.hi * TWO_PWR_32_DBL + (this.lo >>> 0); + if (!Number.isSafeInteger(result)) + throw new Error("cannot convert to safe number"); + return result; + } +} +/** + * 64-bit unsigned integer as two 32-bit values. + * Converts between `string`, `number` and `bigint` representations. + */ +class PbULong extends SharedPbLong { + /** + * Create instance from a `string`, `number` or `bigint`. + */ + static from(value) { + if (BI) + // noinspection FallThroughInSwitchStatementJS + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + if (value == "") + throw new Error('string is no integer'); + value = BI.C(value); + case "number": + if (value === 0) + return this.ZERO; + value = BI.C(value); + case "bigint": + if (!value) + return this.ZERO; + if (value < BI.UMIN) + throw new Error('signed value for ulong'); + if (value > BI.UMAX) + throw new Error('ulong too large'); + BI.V.setBigUint64(0, value, true); + return new PbULong(BI.V.getInt32(0, true), BI.V.getInt32(4, true)); + } + else + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + value = value.trim(); + if (!RE_DECIMAL_STR.test(value)) + throw new Error('string is no integer'); + let [minus, lo, hi] = goog_varint_1.int64fromString(value); + if (minus) + throw new Error('signed value for ulong'); + return new PbULong(lo, hi); + case "number": + if (value == 0) + return this.ZERO; + if (!Number.isSafeInteger(value)) + throw new Error('number is no integer'); + if (value < 0) + throw new Error('signed value for ulong'); + return new PbULong(value, value / TWO_PWR_32_DBL); + } + throw new Error('unknown value ' + typeof value); + } + /** + * Convert to decimal string. + */ + toString() { + return BI ? this.toBigInt().toString() : goog_varint_1.int64toString(this.lo, this.hi); + } + /** + * Convert to native bigint. + */ + toBigInt() { + assertBi(BI); + BI.V.setInt32(0, this.lo, true); + BI.V.setInt32(4, this.hi, true); + return BI.V.getBigUint64(0, true); + } +} +exports.PbULong = PbULong; +/** + * ulong 0 singleton. + */ +PbULong.ZERO = new PbULong(0, 0); +/** + * 64-bit signed integer as two 32-bit values. + * Converts between `string`, `number` and `bigint` representations. + */ +class PbLong extends SharedPbLong { + /** + * Create instance from a `string`, `number` or `bigint`. + */ + static from(value) { + if (BI) + // noinspection FallThroughInSwitchStatementJS + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + if (value == "") + throw new Error('string is no integer'); + value = BI.C(value); + case "number": + if (value === 0) + return this.ZERO; + value = BI.C(value); + case "bigint": + if (!value) + return this.ZERO; + if (value < BI.MIN) + throw new Error('signed long too small'); + if (value > BI.MAX) + throw new Error('signed long too large'); + BI.V.setBigInt64(0, value, true); + return new PbLong(BI.V.getInt32(0, true), BI.V.getInt32(4, true)); + } + else + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + value = value.trim(); + if (!RE_DECIMAL_STR.test(value)) + throw new Error('string is no integer'); + let [minus, lo, hi] = goog_varint_1.int64fromString(value); + if (minus) { + if (hi > HALF_2_PWR_32 || (hi == HALF_2_PWR_32 && lo != 0)) + throw new Error('signed long too small'); + } + else if (hi >= HALF_2_PWR_32) + throw new Error('signed long too large'); + let pbl = new PbLong(lo, hi); + return minus ? pbl.negate() : pbl; + case "number": + if (value == 0) + return this.ZERO; + if (!Number.isSafeInteger(value)) + throw new Error('number is no integer'); + return value > 0 + ? new PbLong(value, value / TWO_PWR_32_DBL) + : new PbLong(-value, -value / TWO_PWR_32_DBL).negate(); + } + throw new Error('unknown value ' + typeof value); + } + /** + * Do we have a minus sign? + */ + isNegative() { + return (this.hi & HALF_2_PWR_32) !== 0; + } + /** + * Negate two's complement. + * Invert all the bits and add one to the result. + */ + negate() { + let hi = ~this.hi, lo = this.lo; + if (lo) + lo = ~lo + 1; + else + hi += 1; + return new PbLong(lo, hi); + } + /** + * Convert to decimal string. + */ + toString() { + if (BI) + return this.toBigInt().toString(); + if (this.isNegative()) { + let n = this.negate(); + return '-' + goog_varint_1.int64toString(n.lo, n.hi); + } + return goog_varint_1.int64toString(this.lo, this.hi); + } + /** + * Convert to native bigint. + */ + toBigInt() { + assertBi(BI); + BI.V.setInt32(0, this.lo, true); + BI.V.setInt32(4, this.hi, true); + return BI.V.getBigInt64(0, true); + } +} +exports.PbLong = PbLong; +/** + * long 0 singleton. + */ +PbLong.ZERO = new PbLong(0, 0); + + +/***/ }), + +/***/ 5290: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// Copyright (c) 2016, Daniel Wirtz All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of its author, nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.utf8read = void 0; +const fromCharCodes = (chunk) => String.fromCharCode.apply(String, chunk); +/** + * @deprecated This function will no longer be exported with the next major + * release, since protobuf-ts has switch to TextDecoder API. If you need this + * function, please migrate to @protobufjs/utf8. For context, see + * https://github.com/timostamm/protobuf-ts/issues/184 + * + * Reads UTF8 bytes as a string. + * + * See [protobufjs / utf8](https://github.com/protobufjs/protobuf.js/blob/9893e35b854621cce64af4bf6be2cff4fb892796/lib/utf8/index.js#L40) + * + * Copyright (c) 2016, Daniel Wirtz + */ +function utf8read(bytes) { + if (bytes.length < 1) + return ""; + let pos = 0, // position in bytes + parts = [], chunk = [], i = 0, // char offset + t; // temporary + let len = bytes.length; + while (pos < len) { + t = bytes[pos++]; + if (t < 128) + chunk[i++] = t; + else if (t > 191 && t < 224) + chunk[i++] = (t & 31) << 6 | bytes[pos++] & 63; + else if (t > 239 && t < 365) { + t = ((t & 7) << 18 | (bytes[pos++] & 63) << 12 | (bytes[pos++] & 63) << 6 | bytes[pos++] & 63) - 0x10000; + chunk[i++] = 0xD800 + (t >> 10); + chunk[i++] = 0xDC00 + (t & 1023); + } + else + chunk[i++] = (t & 15) << 12 | (bytes[pos++] & 63) << 6 | bytes[pos++] & 63; + if (i > 8191) { + parts.push(fromCharCodes(chunk)); + i = 0; + } + } + if (parts.length) { + if (i) + parts.push(fromCharCodes(chunk.slice(0, i))); + return parts.join(""); + } + return fromCharCodes(chunk.slice(0, i)); +} +exports.utf8read = utf8read; + + +/***/ }), + +/***/ 1593: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionBinaryReader = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_long_convert_1 = __nccwpck_require__(4612); +const reflection_scalar_default_1 = __nccwpck_require__(4863); +/** + * Reads proto3 messages in binary format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/encoding + */ +class ReflectionBinaryReader { + constructor(info) { + this.info = info; + } + prepare() { + var _a; + if (!this.fieldNoToField) { + const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : []; + this.fieldNoToField = new Map(fieldsInput.map(field => [field.no, field])); + } + } + /** + * Reads a message from binary format into the target message. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ + read(reader, message, options, length) { + this.prepare(); + const end = length === undefined ? reader.len : reader.pos + length; + while (reader.pos < end) { + // read the tag and find the field + const [fieldNo, wireType] = reader.tag(), field = this.fieldNoToField.get(fieldNo); + if (!field) { + let u = options.readUnknownField; + if (u == "throw") + throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.info.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? binary_format_contract_1.UnknownFieldHandler.onRead : u)(this.info.typeName, message, fieldNo, wireType, d); + continue; + } + // target object for the field we are reading + let target = message, repeated = field.repeat, localName = field.localName; + // if field is member of oneof ADT, use ADT as target + if (field.oneof) { + target = target[field.oneof]; + // if other oneof member selected, set new ADT + if (target.oneofKind !== localName) + target = message[field.oneof] = { + oneofKind: localName + }; + } + // we have handled oneof above, we just have read the value into `target[localName]` + switch (field.kind) { + case "scalar": + case "enum": + let T = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + let L = field.kind == "scalar" ? field.L : undefined; + if (repeated) { + let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values + if (wireType == binary_format_contract_1.WireType.LengthDelimited && T != reflection_info_1.ScalarType.STRING && T != reflection_info_1.ScalarType.BYTES) { + let e = reader.uint32() + reader.pos; + while (reader.pos < e) + arr.push(this.scalar(reader, T, L)); + } + else + arr.push(this.scalar(reader, T, L)); + } + else + target[localName] = this.scalar(reader, T, L); + break; + case "message": + if (repeated) { + let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values + let msg = field.T().internalBinaryRead(reader, reader.uint32(), options); + arr.push(msg); + } + else + target[localName] = field.T().internalBinaryRead(reader, reader.uint32(), options, target[localName]); + break; + case "map": + let [mapKey, mapVal] = this.mapEntry(field, reader, options); + // safe to assume presence of map object, oneof cannot contain repeated values + target[localName][mapKey] = mapVal; + break; + } + } + } + /** + * Read a map field, expecting key field = 1, value field = 2 + */ + mapEntry(field, reader, options) { + let length = reader.uint32(); + let end = reader.pos + length; + let key = undefined; // javascript only allows number or string for object properties + let val = undefined; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case 1: + if (field.K == reflection_info_1.ScalarType.BOOL) + key = reader.bool().toString(); + else + // long types are read as string, number types are okay as number + key = this.scalar(reader, field.K, reflection_info_1.LongType.STRING); + break; + case 2: + switch (field.V.kind) { + case "scalar": + val = this.scalar(reader, field.V.T, field.V.L); + break; + case "enum": + val = reader.int32(); + break; + case "message": + val = field.V.T().internalBinaryRead(reader, reader.uint32(), options); + break; + } + break; + default: + throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) in map entry for ${this.info.typeName}#${field.name}`); + } + } + if (key === undefined) { + let keyRaw = reflection_scalar_default_1.reflectionScalarDefault(field.K); + key = field.K == reflection_info_1.ScalarType.BOOL ? keyRaw.toString() : keyRaw; + } + if (val === undefined) + switch (field.V.kind) { + case "scalar": + val = reflection_scalar_default_1.reflectionScalarDefault(field.V.T, field.V.L); + break; + case "enum": + val = 0; + break; + case "message": + val = field.V.T().create(); + break; + } + return [key, val]; + } + scalar(reader, type, longType) { + switch (type) { + case reflection_info_1.ScalarType.INT32: + return reader.int32(); + case reflection_info_1.ScalarType.STRING: + return reader.string(); + case reflection_info_1.ScalarType.BOOL: + return reader.bool(); + case reflection_info_1.ScalarType.DOUBLE: + return reader.double(); + case reflection_info_1.ScalarType.FLOAT: + return reader.float(); + case reflection_info_1.ScalarType.INT64: + return reflection_long_convert_1.reflectionLongConvert(reader.int64(), longType); + case reflection_info_1.ScalarType.UINT64: + return reflection_long_convert_1.reflectionLongConvert(reader.uint64(), longType); + case reflection_info_1.ScalarType.FIXED64: + return reflection_long_convert_1.reflectionLongConvert(reader.fixed64(), longType); + case reflection_info_1.ScalarType.FIXED32: + return reader.fixed32(); + case reflection_info_1.ScalarType.BYTES: + return reader.bytes(); + case reflection_info_1.ScalarType.UINT32: + return reader.uint32(); + case reflection_info_1.ScalarType.SFIXED32: + return reader.sfixed32(); + case reflection_info_1.ScalarType.SFIXED64: + return reflection_long_convert_1.reflectionLongConvert(reader.sfixed64(), longType); + case reflection_info_1.ScalarType.SINT32: + return reader.sint32(); + case reflection_info_1.ScalarType.SINT64: + return reflection_long_convert_1.reflectionLongConvert(reader.sint64(), longType); + } + } +} +exports.ReflectionBinaryReader = ReflectionBinaryReader; + + +/***/ }), + +/***/ 7170: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionBinaryWriter = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const reflection_info_1 = __nccwpck_require__(1370); +const assert_1 = __nccwpck_require__(4253); +const pb_long_1 = __nccwpck_require__(7777); +/** + * Writes proto3 messages in binary format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/encoding + */ +class ReflectionBinaryWriter { + constructor(info) { + this.info = info; + } + prepare() { + if (!this.fields) { + const fieldsInput = this.info.fields ? this.info.fields.concat() : []; + this.fields = fieldsInput.sort((a, b) => a.no - b.no); + } + } + /** + * Writes the message to binary format. + */ + write(message, writer, options) { + this.prepare(); + for (const field of this.fields) { + let value, // this will be our field value, whether it is member of a oneof or not + emitDefault, // whether we emit the default value (only true for oneof members) + repeated = field.repeat, localName = field.localName; + // handle oneof ADT + if (field.oneof) { + const group = message[field.oneof]; + if (group.oneofKind !== localName) + continue; // if field is not selected, skip + value = group[localName]; + emitDefault = true; + } + else { + value = message[localName]; + emitDefault = false; + } + // we have handled oneof above. we just have to honor `emitDefault`. + switch (field.kind) { + case "scalar": + case "enum": + let T = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + if (repeated) { + assert_1.assert(Array.isArray(value)); + if (repeated == reflection_info_1.RepeatType.PACKED) + this.packed(writer, T, field.no, value); + else + for (const item of value) + this.scalar(writer, T, field.no, item, true); + } + else if (value === undefined) + assert_1.assert(field.opt); + else + this.scalar(writer, T, field.no, value, emitDefault || field.opt); + break; + case "message": + if (repeated) { + assert_1.assert(Array.isArray(value)); + for (const item of value) + this.message(writer, options, field.T(), field.no, item); + } + else { + this.message(writer, options, field.T(), field.no, value); + } + break; + case "map": + assert_1.assert(typeof value == 'object' && value !== null); + for (const [key, val] of Object.entries(value)) + this.mapEntry(writer, options, field, key, val); + break; + } + } + let u = options.writeUnknownFields; + if (u !== false) + (u === true ? binary_format_contract_1.UnknownFieldHandler.onWrite : u)(this.info.typeName, message, writer); + } + mapEntry(writer, options, field, key, value) { + writer.tag(field.no, binary_format_contract_1.WireType.LengthDelimited); + writer.fork(); + // javascript only allows number or string for object properties + // we convert from our representation to the protobuf type + let keyValue = key; + switch (field.K) { + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.UINT32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + keyValue = Number.parseInt(key); + break; + case reflection_info_1.ScalarType.BOOL: + assert_1.assert(key == 'true' || key == 'false'); + keyValue = key == 'true'; + break; + } + // write key, expecting key field number = 1 + this.scalar(writer, field.K, 1, keyValue, true); + // write value, expecting value field number = 2 + switch (field.V.kind) { + case 'scalar': + this.scalar(writer, field.V.T, 2, value, true); + break; + case 'enum': + this.scalar(writer, reflection_info_1.ScalarType.INT32, 2, value, true); + break; + case 'message': + this.message(writer, options, field.V.T(), 2, value); + break; + } + writer.join(); + } + message(writer, options, handler, fieldNo, value) { + if (value === undefined) + return; + handler.internalBinaryWrite(value, writer.tag(fieldNo, binary_format_contract_1.WireType.LengthDelimited).fork(), options); + writer.join(); + } + /** + * Write a single scalar value. + */ + scalar(writer, type, fieldNo, value, emitDefault) { + let [wireType, method, isDefault] = this.scalarInfo(type, value); + if (!isDefault || emitDefault) { + writer.tag(fieldNo, wireType); + writer[method](value); + } + } + /** + * Write an array of scalar values in packed format. + */ + packed(writer, type, fieldNo, value) { + if (!value.length) + return; + assert_1.assert(type !== reflection_info_1.ScalarType.BYTES && type !== reflection_info_1.ScalarType.STRING); + // write tag + writer.tag(fieldNo, binary_format_contract_1.WireType.LengthDelimited); + // begin length-delimited + writer.fork(); + // write values without tags + let [, method,] = this.scalarInfo(type); + for (let i = 0; i < value.length; i++) + writer[method](value[i]); + // end length delimited + writer.join(); + } + /** + * Get information for writing a scalar value. + * + * Returns tuple: + * [0]: appropriate WireType + * [1]: name of the appropriate method of IBinaryWriter + * [2]: whether the given value is a default value + * + * If argument `value` is omitted, [2] is always false. + */ + scalarInfo(type, value) { + let t = binary_format_contract_1.WireType.Varint; + let m; + let i = value === undefined; + let d = value === 0; + switch (type) { + case reflection_info_1.ScalarType.INT32: + m = "int32"; + break; + case reflection_info_1.ScalarType.STRING: + d = i || !value.length; + t = binary_format_contract_1.WireType.LengthDelimited; + m = "string"; + break; + case reflection_info_1.ScalarType.BOOL: + d = value === false; + m = "bool"; + break; + case reflection_info_1.ScalarType.UINT32: + m = "uint32"; + break; + case reflection_info_1.ScalarType.DOUBLE: + t = binary_format_contract_1.WireType.Bit64; + m = "double"; + break; + case reflection_info_1.ScalarType.FLOAT: + t = binary_format_contract_1.WireType.Bit32; + m = "float"; + break; + case reflection_info_1.ScalarType.INT64: + d = i || pb_long_1.PbLong.from(value).isZero(); + m = "int64"; + break; + case reflection_info_1.ScalarType.UINT64: + d = i || pb_long_1.PbULong.from(value).isZero(); + m = "uint64"; + break; + case reflection_info_1.ScalarType.FIXED64: + d = i || pb_long_1.PbULong.from(value).isZero(); + t = binary_format_contract_1.WireType.Bit64; + m = "fixed64"; + break; + case reflection_info_1.ScalarType.BYTES: + d = i || !value.byteLength; + t = binary_format_contract_1.WireType.LengthDelimited; + m = "bytes"; + break; + case reflection_info_1.ScalarType.FIXED32: + t = binary_format_contract_1.WireType.Bit32; + m = "fixed32"; + break; + case reflection_info_1.ScalarType.SFIXED32: + t = binary_format_contract_1.WireType.Bit32; + m = "sfixed32"; + break; + case reflection_info_1.ScalarType.SFIXED64: + d = i || pb_long_1.PbLong.from(value).isZero(); + t = binary_format_contract_1.WireType.Bit64; + m = "sfixed64"; + break; + case reflection_info_1.ScalarType.SINT32: + m = "sint32"; + break; + case reflection_info_1.ScalarType.SINT64: + d = i || pb_long_1.PbLong.from(value).isZero(); + m = "sint64"; + break; + } + return [t, m, i || d]; + } +} +exports.ReflectionBinaryWriter = ReflectionBinaryWriter; + + +/***/ }), + +/***/ 7317: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.containsMessageType = void 0; +const message_type_contract_1 = __nccwpck_require__(1682); +/** + * Check if the provided object is a proto message. + * + * Note that this is an experimental feature - it is here to stay, but + * implementation details may change without notice. + */ +function containsMessageType(msg) { + return msg[message_type_contract_1.MESSAGE_TYPE] != null; +} +exports.containsMessageType = containsMessageType; + + +/***/ }), + +/***/ 390: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionCreate = void 0; +const reflection_scalar_default_1 = __nccwpck_require__(4863); +const message_type_contract_1 = __nccwpck_require__(1682); +/** + * Creates an instance of the generic message, using the field + * information. + */ +function reflectionCreate(type) { + /** + * This ternary can be removed in the next major version. + * The `Object.create()` code path utilizes a new `messagePrototype` + * property on the `IMessageType` which has this same `MESSAGE_TYPE` + * non-enumerable property on it. Doing it this way means that we only + * pay the cost of `Object.defineProperty()` once per `IMessageType` + * class of once per "instance". The falsy code path is only provided + * for backwards compatibility in cases where the runtime library is + * updated without also updating the generated code. + */ + const msg = type.messagePrototype + ? Object.create(type.messagePrototype) + : Object.defineProperty({}, message_type_contract_1.MESSAGE_TYPE, { value: type }); + for (let field of type.fields) { + let name = field.localName; + if (field.opt) + continue; + if (field.oneof) + msg[field.oneof] = { oneofKind: undefined }; + else if (field.repeat) + msg[name] = []; + else + switch (field.kind) { + case "scalar": + msg[name] = reflection_scalar_default_1.reflectionScalarDefault(field.T, field.L); + break; + case "enum": + // we require 0 to be default value for all enums + msg[name] = 0; + break; + case "map": + msg[name] = {}; + break; + } + } + return msg; +} +exports.reflectionCreate = reflectionCreate; + + +/***/ }), + +/***/ 9473: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionEquals = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +/** + * Determines whether two message of the same type have the same field values. + * Checks for deep equality, traversing repeated fields, oneof groups, maps + * and messages recursively. + * Will also return true if both messages are `undefined`. + */ +function reflectionEquals(info, a, b) { + if (a === b) + return true; + if (!a || !b) + return false; + for (let field of info.fields) { + let localName = field.localName; + let val_a = field.oneof ? a[field.oneof][localName] : a[localName]; + let val_b = field.oneof ? b[field.oneof][localName] : b[localName]; + switch (field.kind) { + case "enum": + case "scalar": + let t = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + if (!(field.repeat + ? repeatedPrimitiveEq(t, val_a, val_b) + : primitiveEq(t, val_a, val_b))) + return false; + break; + case "map": + if (!(field.V.kind == "message" + ? repeatedMsgEq(field.V.T(), objectValues(val_a), objectValues(val_b)) + : repeatedPrimitiveEq(field.V.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.V.T, objectValues(val_a), objectValues(val_b)))) + return false; + break; + case "message": + let T = field.T(); + if (!(field.repeat + ? repeatedMsgEq(T, val_a, val_b) + : T.equals(val_a, val_b))) + return false; + break; + } + } + return true; +} +exports.reflectionEquals = reflectionEquals; +const objectValues = Object.values; +function primitiveEq(type, a, b) { + if (a === b) + return true; + if (type !== reflection_info_1.ScalarType.BYTES) + return false; + let ba = a; + let bb = b; + if (ba.length !== bb.length) + return false; + for (let i = 0; i < ba.length; i++) + if (ba[i] != bb[i]) + return false; + return true; +} +function repeatedPrimitiveEq(type, a, b) { + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; i++) + if (!primitiveEq(type, a[i], b[i])) + return false; + return true; +} +function repeatedMsgEq(type, a, b) { + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; i++) + if (!type.equals(a[i], b[i])) + return false; + return true; +} + + +/***/ }), + +/***/ 1370: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.readMessageOption = exports.readFieldOption = exports.readFieldOptions = exports.normalizeFieldInfo = exports.RepeatType = exports.LongType = exports.ScalarType = void 0; +const lower_camel_case_1 = __nccwpck_require__(4772); +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +var ScalarType; +(function (ScalarType) { + // 0 is reserved for errors. + // Order is weird for historical reasons. + ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE"; + ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + ScalarType[ScalarType["INT64"] = 3] = "INT64"; + ScalarType[ScalarType["UINT64"] = 4] = "UINT64"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + ScalarType[ScalarType["INT32"] = 5] = "INT32"; + ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64"; + ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32"; + ScalarType[ScalarType["BOOL"] = 8] = "BOOL"; + ScalarType[ScalarType["STRING"] = 9] = "STRING"; + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + // TYPE_GROUP = 10, + // TYPE_MESSAGE = 11, // Length-delimited aggregate. + // New in version 2. + ScalarType[ScalarType["BYTES"] = 12] = "BYTES"; + ScalarType[ScalarType["UINT32"] = 13] = "UINT32"; + // TYPE_ENUM = 14, + ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32"; + ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64"; + ScalarType[ScalarType["SINT32"] = 17] = "SINT32"; + ScalarType[ScalarType["SINT64"] = 18] = "SINT64"; +})(ScalarType = exports.ScalarType || (exports.ScalarType = {})); +/** + * JavaScript representation of 64 bit integral types. Equivalent to the + * field option "jstype". + * + * By default, protobuf-ts represents 64 bit types as `bigint`. + * + * You can change the default behaviour by enabling the plugin parameter + * `long_type_string`, which will represent 64 bit types as `string`. + * + * Alternatively, you can change the behaviour for individual fields + * with the field option "jstype": + * + * ```protobuf + * uint64 my_field = 1 [jstype = JS_STRING]; + * uint64 other_field = 2 [jstype = JS_NUMBER]; + * ``` + */ +var LongType; +(function (LongType) { + /** + * Use JavaScript `bigint`. + * + * Field option `[jstype = JS_NORMAL]`. + */ + LongType[LongType["BIGINT"] = 0] = "BIGINT"; + /** + * Use JavaScript `string`. + * + * Field option `[jstype = JS_STRING]`. + */ + LongType[LongType["STRING"] = 1] = "STRING"; + /** + * Use JavaScript `number`. + * + * Large values will loose precision. + * + * Field option `[jstype = JS_NUMBER]`. + */ + LongType[LongType["NUMBER"] = 2] = "NUMBER"; +})(LongType = exports.LongType || (exports.LongType = {})); +/** + * Protobuf 2.1.0 introduced packed repeated fields. + * Setting the field option `[packed = true]` enables packing. + * + * In proto3, all repeated fields are packed by default. + * Setting the field option `[packed = false]` disables packing. + * + * Packed repeated fields are encoded with a single tag, + * then a length-delimiter, then the element values. + * + * Unpacked repeated fields are encoded with a tag and + * value for each element. + * + * `bytes` and `string` cannot be packed. + */ +var RepeatType; +(function (RepeatType) { + /** + * The field is not repeated. + */ + RepeatType[RepeatType["NO"] = 0] = "NO"; + /** + * The field is repeated and should be packed. + * Invalid for `bytes` and `string`, they cannot be packed. + */ + RepeatType[RepeatType["PACKED"] = 1] = "PACKED"; + /** + * The field is repeated but should not be packed. + * The only valid repeat type for repeated `bytes` and `string`. + */ + RepeatType[RepeatType["UNPACKED"] = 2] = "UNPACKED"; +})(RepeatType = exports.RepeatType || (exports.RepeatType = {})); +/** + * Turns PartialFieldInfo into FieldInfo. + */ +function normalizeFieldInfo(field) { + var _a, _b, _c, _d; + field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lower_camel_case_1.lowerCamelCase(field.name); + field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lower_camel_case_1.lowerCamelCase(field.name); + field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO; + field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : (field.repeat ? false : field.oneof ? false : field.kind == "message"); + return field; +} +exports.normalizeFieldInfo = normalizeFieldInfo; +/** + * Read custom field options from a generated message type. + * + * @deprecated use readFieldOption() + */ +function readFieldOptions(messageType, fieldName, extensionName, extensionType) { + var _a; + const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options; + return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : undefined; +} +exports.readFieldOptions = readFieldOptions; +function readFieldOption(messageType, fieldName, extensionName, extensionType) { + var _a; + const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readFieldOption = readFieldOption; +function readMessageOption(messageType, extensionName, extensionType) { + const options = messageType.options; + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readMessageOption = readMessageOption; + + +/***/ }), + +/***/ 229: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionJsonReader = void 0; +const json_typings_1 = __nccwpck_require__(661); +const base64_1 = __nccwpck_require__(196); +const reflection_info_1 = __nccwpck_require__(1370); +const pb_long_1 = __nccwpck_require__(7777); +const assert_1 = __nccwpck_require__(4253); +const reflection_long_convert_1 = __nccwpck_require__(4612); +/** + * Reads proto3 messages in canonical JSON format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/proto3#json + */ +class ReflectionJsonReader { + constructor(info) { + this.info = info; + } + prepare() { + var _a; + if (this.fMap === undefined) { + this.fMap = {}; + const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : []; + for (const field of fieldsInput) { + this.fMap[field.name] = field; + this.fMap[field.jsonName] = field; + this.fMap[field.localName] = field; + } + } + } + // Cannot parse JSON for #. + assert(condition, fieldName, jsonValue) { + if (!condition) { + let what = json_typings_1.typeofJsonValue(jsonValue); + if (what == "number" || what == "boolean") + what = jsonValue.toString(); + throw new Error(`Cannot parse JSON ${what} for ${this.info.typeName}#${fieldName}`); + } + } + /** + * Reads a message from canonical JSON format into the target message. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ + read(input, message, options) { + this.prepare(); + const oneofsHandled = []; + for (const [jsonKey, jsonValue] of Object.entries(input)) { + const field = this.fMap[jsonKey]; + if (!field) { + if (!options.ignoreUnknownFields) + throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${jsonKey}`); + continue; + } + const localName = field.localName; + // handle oneof ADT + let target; // this will be the target for the field value, whether it is member of a oneof or not + if (field.oneof) { + if (jsonValue === null && (field.kind !== 'enum' || field.T()[0] !== 'google.protobuf.NullValue')) { + continue; + } + // since json objects are unordered by specification, it is not possible to take the last of multiple oneofs + if (oneofsHandled.includes(field.oneof)) + throw new Error(`Multiple members of the oneof group "${field.oneof}" of ${this.info.typeName} are present in JSON.`); + oneofsHandled.push(field.oneof); + target = message[field.oneof] = { + oneofKind: localName + }; + } + else { + target = message; + } + // we have handled oneof above. we just have read the value into `target`. + if (field.kind == 'map') { + if (jsonValue === null) { + continue; + } + // check input + this.assert(json_typings_1.isJsonObject(jsonValue), field.name, jsonValue); + // our target to put map entries into + const fieldObj = target[localName]; + // read entries + for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) { + this.assert(jsonObjValue !== null, field.name + " map value", null); + // read value + let val; + switch (field.V.kind) { + case "message": + val = field.V.T().internalJsonRead(jsonObjValue, options); + break; + case "enum": + val = this.enum(field.V.T(), jsonObjValue, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + break; + case "scalar": + val = this.scalar(jsonObjValue, field.V.T, field.V.L, field.name); + break; + } + this.assert(val !== undefined, field.name + " map value", jsonObjValue); + // read key + let key = jsonObjKey; + if (field.K == reflection_info_1.ScalarType.BOOL) + key = key == "true" ? true : key == "false" ? false : key; + key = this.scalar(key, field.K, reflection_info_1.LongType.STRING, field.name).toString(); + fieldObj[key] = val; + } + } + else if (field.repeat) { + if (jsonValue === null) + continue; + // check input + this.assert(Array.isArray(jsonValue), field.name, jsonValue); + // our target to put array entries into + const fieldArr = target[localName]; + // read array entries + for (const jsonItem of jsonValue) { + this.assert(jsonItem !== null, field.name, null); + let val; + switch (field.kind) { + case "message": + val = field.T().internalJsonRead(jsonItem, options); + break; + case "enum": + val = this.enum(field.T(), jsonItem, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + break; + case "scalar": + val = this.scalar(jsonItem, field.T, field.L, field.name); + break; + } + this.assert(val !== undefined, field.name, jsonValue); + fieldArr.push(val); + } + } + else { + switch (field.kind) { + case "message": + if (jsonValue === null && field.T().typeName != 'google.protobuf.Value') { + this.assert(field.oneof === undefined, field.name + " (oneof member)", null); + continue; + } + target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]); + break; + case "enum": + let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + target[localName] = val; + break; + case "scalar": + target[localName] = this.scalar(jsonValue, field.T, field.L, field.name); + break; + } + } + } + } + /** + * Returns `false` for unrecognized string representations. + * + * google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`). + */ + enum(type, json, fieldName, ignoreUnknownFields) { + if (type[0] == 'google.protobuf.NullValue') + assert_1.assert(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`); + if (json === null) + // we require 0 to be default value for all enums + return 0; + switch (typeof json) { + case "number": + assert_1.assert(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`); + return json; + case "string": + let localEnumName = json; + if (type[2] && json.substring(0, type[2].length) === type[2]) + // lookup without the shared prefix + localEnumName = json.substring(type[2].length); + let enumNumber = type[1][localEnumName]; + if (typeof enumNumber === 'undefined' && ignoreUnknownFields) { + return false; + } + assert_1.assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`); + return enumNumber; + } + assert_1.assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`); + } + scalar(json, type, longType, fieldName) { + let e; + try { + switch (type) { + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + if (json === null) + return .0; + if (json === "NaN") + return Number.NaN; + if (json === "Infinity") + return Number.POSITIVE_INFINITY; + if (json === "-Infinity") + return Number.NEGATIVE_INFINITY; + if (json === "") { + e = "empty string"; + break; + } + if (typeof json == "string" && json.trim().length !== json.length) { + e = "extra whitespace"; + break; + } + if (typeof json != "string" && typeof json != "number") { + break; + } + let float = Number(json); + if (Number.isNaN(float)) { + e = "not a number"; + break; + } + if (!Number.isFinite(float)) { + // infinity and -infinity are handled by string representation above, so this is an error + e = "too large or small"; + break; + } + if (type == reflection_info_1.ScalarType.FLOAT) + assert_1.assertFloat32(float); + return float; + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + case reflection_info_1.ScalarType.UINT32: + if (json === null) + return 0; + let int32; + if (typeof json == "number") + int32 = json; + else if (json === "") + e = "empty string"; + else if (typeof json == "string") { + if (json.trim().length !== json.length) + e = "extra whitespace"; + else + int32 = Number(json); + } + if (int32 === undefined) + break; + if (type == reflection_info_1.ScalarType.UINT32) + assert_1.assertUInt32(int32); + else + assert_1.assertInt32(int32); + return int32; + // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + if (json === null) + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.ZERO, longType); + if (typeof json != "number" && typeof json != "string") + break; + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.from(json), longType); + case reflection_info_1.ScalarType.FIXED64: + case reflection_info_1.ScalarType.UINT64: + if (json === null) + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.ZERO, longType); + if (typeof json != "number" && typeof json != "string") + break; + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.from(json), longType); + // bool: + case reflection_info_1.ScalarType.BOOL: + if (json === null) + return false; + if (typeof json !== "boolean") + break; + return json; + // string: + case reflection_info_1.ScalarType.STRING: + if (json === null) + return ""; + if (typeof json !== "string") { + e = "extra whitespace"; + break; + } + try { + encodeURIComponent(json); + } + catch (e) { + e = "invalid UTF8"; + break; + } + return json; + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case reflection_info_1.ScalarType.BYTES: + if (json === null || json === "") + return new Uint8Array(0); + if (typeof json !== 'string') + break; + return base64_1.base64decode(json); + } + } + catch (error) { + e = error.message; + } + this.assert(false, fieldName + (e ? " - " + e : ""), json); + } +} +exports.ReflectionJsonReader = ReflectionJsonReader; + + +/***/ }), + +/***/ 8980: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionJsonWriter = void 0; +const base64_1 = __nccwpck_require__(196); +const pb_long_1 = __nccwpck_require__(7777); +const reflection_info_1 = __nccwpck_require__(1370); +const assert_1 = __nccwpck_require__(4253); +/** + * Writes proto3 messages in canonical JSON format using reflection + * information. + * + * https://developers.google.com/protocol-buffers/docs/proto3#json + */ +class ReflectionJsonWriter { + constructor(info) { + var _a; + this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : []; + } + /** + * Converts the message to a JSON object, based on the field descriptors. + */ + write(message, options) { + const json = {}, source = message; + for (const field of this.fields) { + // field is not part of a oneof, simply write as is + if (!field.oneof) { + let jsonValue = this.field(field, source[field.localName], options); + if (jsonValue !== undefined) + json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue; + continue; + } + // field is part of a oneof + const group = source[field.oneof]; + if (group.oneofKind !== field.localName) + continue; // not selected, skip + const opt = field.kind == 'scalar' || field.kind == 'enum' + ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options; + let jsonValue = this.field(field, group[field.localName], opt); + assert_1.assert(jsonValue !== undefined); + json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue; + } + return json; + } + field(field, value, options) { + let jsonValue = undefined; + if (field.kind == 'map') { + assert_1.assert(typeof value == "object" && value !== null); + const jsonObj = {}; + switch (field.V.kind) { + case "scalar": + for (const [entryKey, entryValue] of Object.entries(value)) { + const val = this.scalar(field.V.T, entryValue, field.name, false, true); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + case "message": + const messageType = field.V.T(); + for (const [entryKey, entryValue] of Object.entries(value)) { + const val = this.message(messageType, entryValue, field.name, options); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + case "enum": + const enumInfo = field.V.T(); + for (const [entryKey, entryValue] of Object.entries(value)) { + assert_1.assert(entryValue === undefined || typeof entryValue == 'number'); + const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + } + if (options.emitDefaultValues || Object.keys(jsonObj).length > 0) + jsonValue = jsonObj; + } + else if (field.repeat) { + assert_1.assert(Array.isArray(value)); + const jsonArr = []; + switch (field.kind) { + case "scalar": + for (let i = 0; i < value.length; i++) { + const val = this.scalar(field.T, value[i], field.name, field.opt, true); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + case "enum": + const enumInfo = field.T(); + for (let i = 0; i < value.length; i++) { + assert_1.assert(value[i] === undefined || typeof value[i] == 'number'); + const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + case "message": + const messageType = field.T(); + for (let i = 0; i < value.length; i++) { + const val = this.message(messageType, value[i], field.name, options); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + } + // add converted array to json output + if (options.emitDefaultValues || jsonArr.length > 0 || options.emitDefaultValues) + jsonValue = jsonArr; + } + else { + switch (field.kind) { + case "scalar": + jsonValue = this.scalar(field.T, value, field.name, field.opt, options.emitDefaultValues); + break; + case "enum": + jsonValue = this.enum(field.T(), value, field.name, field.opt, options.emitDefaultValues, options.enumAsInteger); + break; + case "message": + jsonValue = this.message(field.T(), value, field.name, options); + break; + } + } + return jsonValue; + } + /** + * Returns `null` as the default for google.protobuf.NullValue. + */ + enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) { + if (type[0] == 'google.protobuf.NullValue') + return !emitDefaultValues && !optional ? undefined : null; + if (value === undefined) { + assert_1.assert(optional); + return undefined; + } + if (value === 0 && !emitDefaultValues && !optional) + // we require 0 to be default value for all enums + return undefined; + assert_1.assert(typeof value == 'number'); + assert_1.assert(Number.isInteger(value)); + if (enumAsInteger || !type[1].hasOwnProperty(value)) + // if we don't now the enum value, just return the number + return value; + if (type[2]) + // restore the dropped prefix + return type[2] + type[1][value]; + return type[1][value]; + } + message(type, value, fieldName, options) { + if (value === undefined) + return options.emitDefaultValues ? null : undefined; + return type.internalJsonWrite(value, options); + } + scalar(type, value, fieldName, optional, emitDefaultValues) { + if (value === undefined) { + assert_1.assert(optional); + return undefined; + } + const ed = emitDefaultValues || optional; + // noinspection FallThroughInSwitchStatementJS + switch (type) { + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assertInt32(value); + return value; + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.UINT32: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assertUInt32(value); + return value; + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case reflection_info_1.ScalarType.FLOAT: + assert_1.assertFloat32(value); + case reflection_info_1.ScalarType.DOUBLE: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assert(typeof value == 'number'); + if (Number.isNaN(value)) + return 'NaN'; + if (value === Number.POSITIVE_INFINITY) + return 'Infinity'; + if (value === Number.NEGATIVE_INFINITY) + return '-Infinity'; + return value; + // string: + case reflection_info_1.ScalarType.STRING: + if (value === "") + return ed ? '' : undefined; + assert_1.assert(typeof value == 'string'); + return value; + // bool: + case reflection_info_1.ScalarType.BOOL: + if (value === false) + return ed ? false : undefined; + assert_1.assert(typeof value == 'boolean'); + return value; + // JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + assert_1.assert(typeof value == 'number' || typeof value == 'string' || typeof value == 'bigint'); + let ulong = pb_long_1.PbULong.from(value); + if (ulong.isZero() && !ed) + return undefined; + return ulong.toString(); + // JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + assert_1.assert(typeof value == 'number' || typeof value == 'string' || typeof value == 'bigint'); + let long = pb_long_1.PbLong.from(value); + if (long.isZero() && !ed) + return undefined; + return long.toString(); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case reflection_info_1.ScalarType.BYTES: + assert_1.assert(value instanceof Uint8Array); + if (!value.byteLength) + return ed ? "" : undefined; + return base64_1.base64encode(value); + } + } +} +exports.ReflectionJsonWriter = ReflectionJsonWriter; + + +/***/ }), + +/***/ 4612: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionLongConvert = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +/** + * Utility method to convert a PbLong or PbUlong to a JavaScript + * representation during runtime. + * + * Works with generated field information, `undefined` is equivalent + * to `STRING`. + */ +function reflectionLongConvert(long, type) { + switch (type) { + case reflection_info_1.LongType.BIGINT: + return long.toBigInt(); + case reflection_info_1.LongType.NUMBER: + return long.toNumber(); + default: + // case undefined: + // case LongType.STRING: + return long.toString(); + } +} +exports.reflectionLongConvert = reflectionLongConvert; + + +/***/ }), + +/***/ 7869: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionMergePartial = void 0; +/** + * Copy partial data into the target message. + * + * If a singular scalar or enum field is present in the source, it + * replaces the field in the target. + * + * If a singular message field is present in the source, it is merged + * with the target field by calling mergePartial() of the responsible + * message type. + * + * If a repeated field is present in the source, its values replace + * all values in the target array, removing extraneous values. + * Repeated message fields are copied, not merged. + * + * If a map field is present in the source, entries are added to the + * target map, replacing entries with the same key. Entries that only + * exist in the target remain. Entries with message values are copied, + * not merged. + * + * Note that this function differs from protobuf merge semantics, + * which appends repeated fields. + */ +function reflectionMergePartial(info, target, source) { + let fieldValue, // the field value we are working with + input = source, output; // where we want our field value to go + for (let field of info.fields) { + let name = field.localName; + if (field.oneof) { + const group = input[field.oneof]; // this is the oneof`s group in the source + if ((group === null || group === void 0 ? void 0 : group.oneofKind) == undefined) { // the user is free to omit + continue; // we skip this field, and all other members too + } + fieldValue = group[name]; // our value comes from the the oneof group of the source + output = target[field.oneof]; // and our output is the oneof group of the target + output.oneofKind = group.oneofKind; // always update discriminator + if (fieldValue == undefined) { + delete output[name]; // remove any existing value + continue; // skip further work on field + } + } + else { + fieldValue = input[name]; // we are using the source directly + output = target; // we want our field value to go directly into the target + if (fieldValue == undefined) { + continue; // skip further work on field, existing value is used as is + } + } + if (field.repeat) + output[name].length = fieldValue.length; // resize target array to match source array + // now we just work with `fieldValue` and `output` to merge the value + switch (field.kind) { + case "scalar": + case "enum": + if (field.repeat) + for (let i = 0; i < fieldValue.length; i++) + output[name][i] = fieldValue[i]; // not a reference type + else + output[name] = fieldValue; // not a reference type + break; + case "message": + let T = field.T(); + if (field.repeat) + for (let i = 0; i < fieldValue.length; i++) + output[name][i] = T.create(fieldValue[i]); + else if (output[name] === undefined) + output[name] = T.create(fieldValue); // nothing to merge with + else + T.mergePartial(output[name], fieldValue); + break; + case "map": + // Map and repeated fields are simply overwritten, not appended or merged + switch (field.V.kind) { + case "scalar": + case "enum": + Object.assign(output[name], fieldValue); // elements are not reference types + break; + case "message": + let T = field.V.T(); + for (let k of Object.keys(fieldValue)) + output[name][k] = T.create(fieldValue[k]); + break; + } + break; + } + } +} +exports.reflectionMergePartial = reflectionMergePartial; + + +/***/ }), + +/***/ 4863: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionScalarDefault = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_long_convert_1 = __nccwpck_require__(4612); +const pb_long_1 = __nccwpck_require__(7777); +/** + * Creates the default value for a scalar type. + */ +function reflectionScalarDefault(type, longType = reflection_info_1.LongType.STRING) { + switch (type) { + case reflection_info_1.ScalarType.BOOL: + return false; + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.ZERO, longType); + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.ZERO, longType); + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + return 0.0; + case reflection_info_1.ScalarType.BYTES: + return new Uint8Array(0); + case reflection_info_1.ScalarType.STRING: + return ""; + default: + // case ScalarType.INT32: + // case ScalarType.UINT32: + // case ScalarType.SINT32: + // case ScalarType.FIXED32: + // case ScalarType.SFIXED32: + return 0; + } +} +exports.reflectionScalarDefault = reflectionScalarDefault; + + +/***/ }), + +/***/ 903: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionTypeCheck = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +const oneof_1 = __nccwpck_require__(8531); +// noinspection JSMethodCanBeStatic +class ReflectionTypeCheck { + constructor(info) { + var _a; + this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : []; + } + prepare() { + if (this.data) + return; + const req = [], known = [], oneofs = []; + for (let field of this.fields) { + if (field.oneof) { + if (!oneofs.includes(field.oneof)) { + oneofs.push(field.oneof); + req.push(field.oneof); + known.push(field.oneof); + } + } + else { + known.push(field.localName); + switch (field.kind) { + case "scalar": + case "enum": + if (!field.opt || field.repeat) + req.push(field.localName); + break; + case "message": + if (field.repeat) + req.push(field.localName); + break; + case "map": + req.push(field.localName); + break; + } + } + } + this.data = { req, known, oneofs: Object.values(oneofs) }; + } + /** + * Is the argument a valid message as specified by the + * reflection information? + * + * Checks all field types recursively. The `depth` + * specifies how deep into the structure the check will be. + * + * With a depth of 0, only the presence of fields + * is checked. + * + * With a depth of 1 or more, the field types are checked. + * + * With a depth of 2 or more, the members of map, repeated + * and message fields are checked. + * + * Message fields will be checked recursively with depth - 1. + * + * The number of map entries / repeated values being checked + * is < depth. + */ + is(message, depth, allowExcessProperties = false) { + if (depth < 0) + return true; + if (message === null || message === undefined || typeof message != 'object') + return false; + this.prepare(); + let keys = Object.keys(message), data = this.data; + // if a required field is missing in arg, this cannot be a T + if (keys.length < data.req.length || data.req.some(n => !keys.includes(n))) + return false; + if (!allowExcessProperties) { + // if the arg contains a key we dont know, this is not a literal T + if (keys.some(k => !data.known.includes(k))) + return false; + } + // "With a depth of 0, only the presence and absence of fields is checked." + // "With a depth of 1 or more, the field types are checked." + if (depth < 1) { + return true; + } + // check oneof group + for (const name of data.oneofs) { + const group = message[name]; + if (!oneof_1.isOneofGroup(group)) + return false; + if (group.oneofKind === undefined) + continue; + const field = this.fields.find(f => f.localName === group.oneofKind); + if (!field) + return false; // we found no field, but have a kind, something is wrong + if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth)) + return false; + } + // check types + for (const field of this.fields) { + if (field.oneof !== undefined) + continue; + if (!this.field(message[field.localName], field, allowExcessProperties, depth)) + return false; + } + return true; + } + field(arg, field, allowExcessProperties, depth) { + let repeated = field.repeat; + switch (field.kind) { + case "scalar": + if (arg === undefined) + return field.opt; + if (repeated) + return this.scalars(arg, field.T, depth, field.L); + return this.scalar(arg, field.T, field.L); + case "enum": + if (arg === undefined) + return field.opt; + if (repeated) + return this.scalars(arg, reflection_info_1.ScalarType.INT32, depth); + return this.scalar(arg, reflection_info_1.ScalarType.INT32); + case "message": + if (arg === undefined) + return true; + if (repeated) + return this.messages(arg, field.T(), allowExcessProperties, depth); + return this.message(arg, field.T(), allowExcessProperties, depth); + case "map": + if (typeof arg != 'object' || arg === null) + return false; + if (depth < 2) + return true; + if (!this.mapKeys(arg, field.K, depth)) + return false; + switch (field.V.kind) { + case "scalar": + return this.scalars(Object.values(arg), field.V.T, depth, field.V.L); + case "enum": + return this.scalars(Object.values(arg), reflection_info_1.ScalarType.INT32, depth); + case "message": + return this.messages(Object.values(arg), field.V.T(), allowExcessProperties, depth); + } + break; + } + return true; + } + message(arg, type, allowExcessProperties, depth) { + if (allowExcessProperties) { + return type.isAssignable(arg, depth); + } + return type.is(arg, depth); + } + messages(arg, type, allowExcessProperties, depth) { + if (!Array.isArray(arg)) + return false; + if (depth < 2) + return true; + if (allowExcessProperties) { + for (let i = 0; i < arg.length && i < depth; i++) + if (!type.isAssignable(arg[i], depth - 1)) + return false; + } + else { + for (let i = 0; i < arg.length && i < depth; i++) + if (!type.is(arg[i], depth - 1)) + return false; + } + return true; + } + scalar(arg, type, longType) { + let argType = typeof arg; + switch (type) { + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + switch (longType) { + case reflection_info_1.LongType.BIGINT: + return argType == "bigint"; + case reflection_info_1.LongType.NUMBER: + return argType == "number" && !isNaN(arg); + default: + return argType == "string"; + } + case reflection_info_1.ScalarType.BOOL: + return argType == 'boolean'; + case reflection_info_1.ScalarType.STRING: + return argType == 'string'; + case reflection_info_1.ScalarType.BYTES: + return arg instanceof Uint8Array; + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + return argType == 'number' && !isNaN(arg); + default: + // case ScalarType.UINT32: + // case ScalarType.FIXED32: + // case ScalarType.INT32: + // case ScalarType.SINT32: + // case ScalarType.SFIXED32: + return argType == 'number' && Number.isInteger(arg); + } + } + scalars(arg, type, depth, longType) { + if (!Array.isArray(arg)) + return false; + if (depth < 2) + return true; + if (Array.isArray(arg)) + for (let i = 0; i < arg.length && i < depth; i++) + if (!this.scalar(arg[i], type, longType)) + return false; + return true; + } + mapKeys(map, type, depth) { + let keys = Object.keys(map); + switch (type) { + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + case reflection_info_1.ScalarType.UINT32: + return this.scalars(keys.slice(0, depth).map(k => parseInt(k)), type, depth); + case reflection_info_1.ScalarType.BOOL: + return this.scalars(keys.slice(0, depth).map(k => k == 'true' ? true : k == 'false' ? false : k), type, depth); + default: + return this.scalars(keys, type, depth, reflection_info_1.LongType.STRING); + } + } +} +exports.ReflectionTypeCheck = ReflectionTypeCheck; + + /***/ }), /***/ 4812: @@ -46176,6 +53055,599 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() { }; +/***/ }), + +/***/ 4365: +/***/ ((module) => { + +"use strict"; + + +function _process (v, mod) { + var i + var r + + if (typeof mod === 'function') { + r = mod(v) + if (r !== undefined) { + v = r + } + } else if (Array.isArray(mod)) { + for (i = 0; i < mod.length; i++) { + r = mod[i](v) + if (r !== undefined) { + v = r + } + } + } + + return v +} + +function parseKey (key, val) { + // detect negative index notation + if (key[0] === '-' && Array.isArray(val) && /^-\d+$/.test(key)) { + return val.length + parseInt(key, 10) + } + return key +} + +function isIndex (k) { + return /^\d+$/.test(k) +} + +function isObject (val) { + return Object.prototype.toString.call(val) === '[object Object]' +} + +function isArrayOrObject (val) { + return Object(val) === val +} + +function isEmptyObject (val) { + return Object.keys(val).length === 0 +} + +var blacklist = ['__proto__', 'prototype', 'constructor'] +var blacklistFilter = function (part) { return blacklist.indexOf(part) === -1 } + +function parsePath (path, sep) { + if (path.indexOf('[') >= 0) { + path = path.replace(/\[/g, sep).replace(/]/g, '') + } + + var parts = path.split(sep) + + var check = parts.filter(blacklistFilter) + + if (check.length !== parts.length) { + throw Error('Refusing to update blacklisted property ' + path) + } + + return parts +} + +var hasOwnProperty = Object.prototype.hasOwnProperty + +function DotObject (separator, override, useArray, useBrackets) { + if (!(this instanceof DotObject)) { + return new DotObject(separator, override, useArray, useBrackets) + } + + if (typeof override === 'undefined') override = false + if (typeof useArray === 'undefined') useArray = true + if (typeof useBrackets === 'undefined') useBrackets = true + this.separator = separator || '.' + this.override = override + this.useArray = useArray + this.useBrackets = useBrackets + this.keepArray = false + + // contains touched arrays + this.cleanup = [] +} + +var dotDefault = new DotObject('.', false, true, true) +function wrap (method) { + return function () { + return dotDefault[method].apply(dotDefault, arguments) + } +} + +DotObject.prototype._fill = function (a, obj, v, mod) { + var k = a.shift() + + if (a.length > 0) { + obj[k] = obj[k] || (this.useArray && isIndex(a[0]) ? [] : {}) + + if (!isArrayOrObject(obj[k])) { + if (this.override) { + obj[k] = {} + } else { + if (!(isArrayOrObject(v) && isEmptyObject(v))) { + throw new Error( + 'Trying to redefine `' + k + '` which is a ' + typeof obj[k] + ) + } + + return + } + } + + this._fill(a, obj[k], v, mod) + } else { + if (!this.override && isArrayOrObject(obj[k]) && !isEmptyObject(obj[k])) { + if (!(isArrayOrObject(v) && isEmptyObject(v))) { + throw new Error("Trying to redefine non-empty obj['" + k + "']") + } + + return + } + + obj[k] = _process(v, mod) + } +} + +/** + * + * Converts an object with dotted-key/value pairs to it's expanded version + * + * Optionally transformed by a set of modifiers. + * + * Usage: + * + * var row = { + * 'nr': 200, + * 'doc.name': ' My Document ' + * } + * + * var mods = { + * 'doc.name': [_s.trim, _s.underscored] + * } + * + * dot.object(row, mods) + * + * @param {Object} obj + * @param {Object} mods + */ +DotObject.prototype.object = function (obj, mods) { + var self = this + + Object.keys(obj).forEach(function (k) { + var mod = mods === undefined ? null : mods[k] + // normalize array notation. + var ok = parsePath(k, self.separator).join(self.separator) + + if (ok.indexOf(self.separator) !== -1) { + self._fill(ok.split(self.separator), obj, obj[k], mod) + delete obj[k] + } else { + obj[k] = _process(obj[k], mod) + } + }) + + return obj +} + +/** + * @param {String} path dotted path + * @param {String} v value to be set + * @param {Object} obj object to be modified + * @param {Function|Array} mod optional modifier + */ +DotObject.prototype.str = function (path, v, obj, mod) { + var ok = parsePath(path, this.separator).join(this.separator) + + if (path.indexOf(this.separator) !== -1) { + this._fill(ok.split(this.separator), obj, v, mod) + } else { + obj[path] = _process(v, mod) + } + + return obj +} + +/** + * + * Pick a value from an object using dot notation. + * + * Optionally remove the value + * + * @param {String} path + * @param {Object} obj + * @param {Boolean} remove + */ +DotObject.prototype.pick = function (path, obj, remove, reindexArray) { + var i + var keys + var val + var key + var cp + + keys = parsePath(path, this.separator) + for (i = 0; i < keys.length; i++) { + key = parseKey(keys[i], obj) + if (obj && typeof obj === 'object' && key in obj) { + if (i === keys.length - 1) { + if (remove) { + val = obj[key] + if (reindexArray && Array.isArray(obj)) { + obj.splice(key, 1) + } else { + delete obj[key] + } + if (Array.isArray(obj)) { + cp = keys.slice(0, -1).join('.') + if (this.cleanup.indexOf(cp) === -1) { + this.cleanup.push(cp) + } + } + return val + } else { + return obj[key] + } + } else { + obj = obj[key] + } + } else { + return undefined + } + } + if (remove && Array.isArray(obj)) { + obj = obj.filter(function (n) { + return n !== undefined + }) + } + return obj +} +/** + * + * Delete value from an object using dot notation. + * + * @param {String} path + * @param {Object} obj + * @return {any} The removed value + */ +DotObject.prototype.delete = function (path, obj) { + return this.remove(path, obj, true) +} + +/** + * + * Remove value from an object using dot notation. + * + * Will remove multiple items if path is an array. + * In this case array indexes will be retained until all + * removals have been processed. + * + * Use dot.delete() to automatically re-index arrays. + * + * @param {String|Array} path + * @param {Object} obj + * @param {Boolean} reindexArray + * @return {any} The removed value + */ +DotObject.prototype.remove = function (path, obj, reindexArray) { + var i + + this.cleanup = [] + if (Array.isArray(path)) { + for (i = 0; i < path.length; i++) { + this.pick(path[i], obj, true, reindexArray) + } + if (!reindexArray) { + this._cleanup(obj) + } + return obj + } else { + return this.pick(path, obj, true, reindexArray) + } +} + +DotObject.prototype._cleanup = function (obj) { + var ret + var i + var keys + var root + if (this.cleanup.length) { + for (i = 0; i < this.cleanup.length; i++) { + keys = this.cleanup[i].split('.') + root = keys.splice(0, -1).join('.') + ret = root ? this.pick(root, obj) : obj + ret = ret[keys[0]].filter(function (v) { + return v !== undefined + }) + this.set(this.cleanup[i], ret, obj) + } + this.cleanup = [] + } +} + +/** + * Alias method for `dot.remove` + * + * Note: this is not an alias for dot.delete() + * + * @param {String|Array} path + * @param {Object} obj + * @param {Boolean} reindexArray + * @return {any} The removed value + */ +DotObject.prototype.del = DotObject.prototype.remove + +/** + * + * Move a property from one place to the other. + * + * If the source path does not exist (undefined) + * the target property will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.move = function (source, target, obj, mods, merge) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set(target, _process(this.pick(source, obj, true), mods), obj, merge) + } else { + merge = mods + this.set(target, this.pick(source, obj, true), obj, merge) + } + + return obj +} + +/** + * + * Transfer a property from one object to another object. + * + * If the source path does not exist (undefined) + * the property on the other object will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj1 + * @param {Object} obj2 + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.transfer = function ( + source, + target, + obj1, + obj2, + mods, + merge +) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set( + target, + _process(this.pick(source, obj1, true), mods), + obj2, + merge + ) + } else { + merge = mods + this.set(target, this.pick(source, obj1, true), obj2, merge) + } + + return obj2 +} + +/** + * + * Copy a property from one object to another object. + * + * If the source path does not exist (undefined) + * the property on the other object will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj1 + * @param {Object} obj2 + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.copy = function (source, target, obj1, obj2, mods, merge) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set( + target, + _process( + // clone what is picked + JSON.parse(JSON.stringify(this.pick(source, obj1, false))), + mods + ), + obj2, + merge + ) + } else { + merge = mods + this.set(target, this.pick(source, obj1, false), obj2, merge) + } + + return obj2 +} + +/** + * + * Set a property on an object using dot notation. + * + * @param {String} path + * @param {any} val + * @param {Object} obj + * @param {Boolean} merge + */ +DotObject.prototype.set = function (path, val, obj, merge) { + var i + var k + var keys + var key + + // Do not operate if the value is undefined. + if (typeof val === 'undefined') { + return obj + } + keys = parsePath(path, this.separator) + + for (i = 0; i < keys.length; i++) { + key = keys[i] + if (i === keys.length - 1) { + if (merge && isObject(val) && isObject(obj[key])) { + for (k in val) { + if (hasOwnProperty.call(val, k)) { + obj[key][k] = val[k] + } + } + } else if (merge && Array.isArray(obj[key]) && Array.isArray(val)) { + for (var j = 0; j < val.length; j++) { + obj[keys[i]].push(val[j]) + } + } else { + obj[key] = val + } + } else if ( + // force the value to be an object + !hasOwnProperty.call(obj, key) || + (!isObject(obj[key]) && !Array.isArray(obj[key])) + ) { + // initialize as array if next key is numeric + if (/^\d+$/.test(keys[i + 1])) { + obj[key] = [] + } else { + obj[key] = {} + } + } + obj = obj[key] + } + return obj +} + +/** + * + * Transform an object + * + * Usage: + * + * var obj = { + * "id": 1, + * "some": { + * "thing": "else" + * } + * } + * + * var transform = { + * "id": "nr", + * "some.thing": "name" + * } + * + * var tgt = dot.transform(transform, obj) + * + * @param {Object} recipe Transform recipe + * @param {Object} obj Object to be transformed + * @param {Array} mods modifiers for the target + */ +DotObject.prototype.transform = function (recipe, obj, tgt) { + obj = obj || {} + tgt = tgt || {} + Object.keys(recipe).forEach( + function (key) { + this.set(recipe[key], this.pick(key, obj), tgt) + }.bind(this) + ) + return tgt +} + +/** + * + * Convert object to dotted-key/value pair + * + * Usage: + * + * var tgt = dot.dot(obj) + * + * or + * + * var tgt = {} + * dot.dot(obj, tgt) + * + * @param {Object} obj source object + * @param {Object} tgt target object + * @param {Array} path path array (internal) + */ +DotObject.prototype.dot = function (obj, tgt, path) { + tgt = tgt || {} + path = path || [] + var isArray = Array.isArray(obj) + + Object.keys(obj).forEach( + function (key) { + var index = isArray && this.useBrackets ? '[' + key + ']' : key + if ( + isArrayOrObject(obj[key]) && + ((isObject(obj[key]) && !isEmptyObject(obj[key])) || + (Array.isArray(obj[key]) && !this.keepArray && obj[key].length !== 0)) + ) { + if (isArray && this.useBrackets) { + var previousKey = path[path.length - 1] || '' + return this.dot( + obj[key], + tgt, + path.slice(0, -1).concat(previousKey + index) + ) + } else { + return this.dot(obj[key], tgt, path.concat(index)) + } + } else { + if (isArray && this.useBrackets) { + tgt[path.join(this.separator).concat('[' + key + ']')] = obj[key] + } else { + tgt[path.concat(index).join(this.separator)] = obj[key] + } + } + }.bind(this) + ) + return tgt +} + +DotObject.pick = wrap('pick') +DotObject.move = wrap('move') +DotObject.transfer = wrap('transfer') +DotObject.transform = wrap('transform') +DotObject.copy = wrap('copy') +DotObject.object = wrap('object') +DotObject.str = wrap('str') +DotObject.set = wrap('set') +DotObject.delete = wrap('delete') +DotObject.del = DotObject.remove = wrap('remove') +DotObject.dot = wrap('dot'); +['override', 'overwrite'].forEach(function (prop) { + Object.defineProperty(DotObject, prop, { + get: function () { + return dotDefault.override + }, + set: function (val) { + dotDefault.override = !!val + } + }) +}); +['useArray', 'keepArray', 'useBrackets'].forEach(function (prop) { + Object.defineProperty(DotObject, prop, { + get: function () { + return dotDefault[prop] + }, + set: function (val) { + dotDefault[prop] = val + } + }) +}) + +DotObject._process = _process + +module.exports = DotObject + + /***/ }), /***/ 7426: @@ -51630,6 +59102,1152 @@ if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { exports.debug = debug; // for test +/***/ }), + +/***/ 1524: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); + + +/***/ }), + +/***/ 6647: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isValidErrorCode = exports.httpStatusFromErrorCode = exports.TwirpErrorCode = exports.BadRouteError = exports.InternalServerErrorWith = exports.InternalServerError = exports.RequiredArgumentError = exports.InvalidArgumentError = exports.NotFoundError = exports.TwirpError = void 0; +/** + * Represents a twirp error + */ +class TwirpError extends Error { + constructor(code, msg) { + super(msg); + this.code = TwirpErrorCode.Internal; + this.meta = {}; + this.code = code; + this.msg = msg; + Object.setPrototypeOf(this, TwirpError.prototype); + } + /** + * Adds a metadata kv to the error + * @param key + * @param value + */ + withMeta(key, value) { + this.meta[key] = value; + return this; + } + /** + * Returns a single metadata value + * return "" if not found + * @param key + */ + getMeta(key) { + return this.meta[key] || ""; + } + /** + * Add the original error cause + * @param err + * @param addMeta + */ + withCause(err, addMeta = false) { + this._originalCause = err; + if (addMeta) { + this.withMeta("cause", err.message); + } + return this; + } + cause() { + return this._originalCause; + } + /** + * Returns the error representation to JSON + */ + toJSON() { + try { + return JSON.stringify({ + code: this.code, + msg: this.msg, + meta: this.meta, + }); + } + catch (e) { + return `{"code": "internal", "msg": "There was an error but it could not be serialized into JSON"}`; + } + } + /** + * Create a twirp error from an object + * @param obj + */ + static fromObject(obj) { + const code = obj["code"] || TwirpErrorCode.Unknown; + const msg = obj["msg"] || "unknown"; + const error = new TwirpError(code, msg); + if (obj["meta"]) { + Object.keys(obj["meta"]).forEach((key) => { + error.withMeta(key, obj["meta"][key]); + }); + } + return error; + } +} +exports.TwirpError = TwirpError; +/** + * NotFoundError constructor for the common NotFound error. + */ +class NotFoundError extends TwirpError { + constructor(msg) { + super(TwirpErrorCode.NotFound, msg); + } +} +exports.NotFoundError = NotFoundError; +/** + * InvalidArgumentError constructor for the common InvalidArgument error. Can be + * used when an argument has invalid format, is a number out of range, is a bad + * option, etc). + */ +class InvalidArgumentError extends TwirpError { + constructor(argument, validationMsg) { + super(TwirpErrorCode.InvalidArgument, argument + " " + validationMsg); + this.withMeta("argument", argument); + } +} +exports.InvalidArgumentError = InvalidArgumentError; +/** + * RequiredArgumentError is a more specific constructor for InvalidArgument + * error. Should be used when the argument is required (expected to have a + * non-zero value). + */ +class RequiredArgumentError extends InvalidArgumentError { + constructor(argument) { + super(argument, "is required"); + } +} +exports.RequiredArgumentError = RequiredArgumentError; +/** + * InternalError constructor for the common Internal error. Should be used to + * specify that something bad or unexpected happened. + */ +class InternalServerError extends TwirpError { + constructor(msg) { + super(TwirpErrorCode.Internal, msg); + } +} +exports.InternalServerError = InternalServerError; +/** + * InternalErrorWith makes an internal error, wrapping the original error and using it + * for the error message, and with metadata "cause" with the original error type. + * This function is used by Twirp services to wrap non-Twirp errors as internal errors. + * The wrapped error can be extracted later with err.cause() + */ +class InternalServerErrorWith extends InternalServerError { + constructor(err) { + super(err.message); + this.withMeta("cause", err.name); + this.withCause(err); + } +} +exports.InternalServerErrorWith = InternalServerErrorWith; +/** + * A standard BadRoute Error + */ +class BadRouteError extends TwirpError { + constructor(msg, method, url) { + super(TwirpErrorCode.BadRoute, msg); + this.withMeta("twirp_invalid_route", method + " " + url); + } +} +exports.BadRouteError = BadRouteError; +var TwirpErrorCode; +(function (TwirpErrorCode) { + // Canceled indicates the operation was cancelled (typically by the caller). + TwirpErrorCode["Canceled"] = "canceled"; + // Unknown error. For example when handling errors raised by APIs that do not + // return enough error information. + TwirpErrorCode["Unknown"] = "unknown"; + // InvalidArgument indicates client specified an invalid argument. It + // indicates arguments that are problematic regardless of the state of the + // system (i.e. a malformed file name, required argument, number out of range, + // etc.). + TwirpErrorCode["InvalidArgument"] = "invalid_argument"; + // Malformed indicates an error occurred while decoding the client's request. + // This may mean that the message was encoded improperly, or that there is a + // disagreement in message format between the client and server. + TwirpErrorCode["Malformed"] = "malformed"; + // DeadlineExceeded means operation expired before completion. For operations + // that change the state of the system, this error may be returned even if the + // operation has completed successfully (timeout). + TwirpErrorCode["DeadlineExceeded"] = "deadline_exceeded"; + // NotFound means some requested entity was not found. + TwirpErrorCode["NotFound"] = "not_found"; + // BadRoute means that the requested URL path wasn't routable to a Twirp + // service and method. This is returned by the generated server, and usually + // shouldn't be returned by applications. Instead, applications should use + // NotFound or Unimplemented. + TwirpErrorCode["BadRoute"] = "bad_route"; + // AlreadyExists means an attempt to create an entity failed because one + // already exists. + TwirpErrorCode["AlreadyExists"] = "already_exists"; + // PermissionDenied indicates the caller does not have permission to execute + // the specified operation. It must not be used if the caller cannot be + // identified (Unauthenticated). + TwirpErrorCode["PermissionDenied"] = "permission_denied"; + // Unauthenticated indicates the request does not have valid authentication + // credentials for the operation. + TwirpErrorCode["Unauthenticated"] = "unauthenticated"; + // ResourceExhausted indicates some resource has been exhausted, perhaps a + // per-user quota, or perhaps the entire file system is out of space. + TwirpErrorCode["ResourceExhausted"] = "resource_exhausted"; + // FailedPrecondition indicates operation was rejected because the system is + // not in a state required for the operation's execution. For example, doing + // an rmdir operation on a directory that is non-empty, or on a non-directory + // object, or when having conflicting read-modify-write on the same resource. + TwirpErrorCode["FailedPrecondition"] = "failed_precondition"; + // Aborted indicates the operation was aborted, typically due to a concurrency + // issue like sequencer check failures, transaction aborts, etc. + TwirpErrorCode["Aborted"] = "aborted"; + // OutOfRange means operation was attempted past the valid range. For example, + // seeking or reading past end of a paginated collection. + // + // Unlike InvalidArgument, this error indicates a problem that may be fixed if + // the system state changes (i.e. adding more items to the collection). + // + // There is a fair bit of overlap between FailedPrecondition and OutOfRange. + // We recommend using OutOfRange (the more specific error) when it applies so + // that callers who are iterating through a space can easily look for an + // OutOfRange error to detect when they are done. + TwirpErrorCode["OutOfRange"] = "out_of_range"; + // Unimplemented indicates operation is not implemented or not + // supported/enabled in this service. + TwirpErrorCode["Unimplemented"] = "unimplemented"; + // Internal errors. When some invariants expected by the underlying system + // have been broken. In other words, something bad happened in the library or + // backend service. Do not confuse with HTTP Internal Server Error; an + // Internal error could also happen on the client code, i.e. when parsing a + // server response. + TwirpErrorCode["Internal"] = "internal"; + // Unavailable indicates the service is currently unavailable. This is a most + // likely a transient condition and may be corrected by retrying with a + // backoff. + TwirpErrorCode["Unavailable"] = "unavailable"; + // DataLoss indicates unrecoverable data loss or corruption. + TwirpErrorCode["DataLoss"] = "data_loss"; +})(TwirpErrorCode = exports.TwirpErrorCode || (exports.TwirpErrorCode = {})); +// ServerHTTPStatusFromErrorCode maps a Twirp error type into a similar HTTP +// response status. It is used by the Twirp server handler to set the HTTP +// response status code. Returns 0 if the ErrorCode is invalid. +function httpStatusFromErrorCode(code) { + switch (code) { + case TwirpErrorCode.Canceled: + return 408; // RequestTimeout + case TwirpErrorCode.Unknown: + return 500; // Internal Server Error + case TwirpErrorCode.InvalidArgument: + return 400; // BadRequest + case TwirpErrorCode.Malformed: + return 400; // BadRequest + case TwirpErrorCode.DeadlineExceeded: + return 408; // RequestTimeout + case TwirpErrorCode.NotFound: + return 404; // Not Found + case TwirpErrorCode.BadRoute: + return 404; // Not Found + case TwirpErrorCode.AlreadyExists: + return 409; // Conflict + case TwirpErrorCode.PermissionDenied: + return 403; // Forbidden + case TwirpErrorCode.Unauthenticated: + return 401; // Unauthorized + case TwirpErrorCode.ResourceExhausted: + return 429; // Too Many Requests + case TwirpErrorCode.FailedPrecondition: + return 412; // Precondition Failed + case TwirpErrorCode.Aborted: + return 409; // Conflict + case TwirpErrorCode.OutOfRange: + return 400; // Bad Request + case TwirpErrorCode.Unimplemented: + return 501; // Not Implemented + case TwirpErrorCode.Internal: + return 500; // Internal Server Error + case TwirpErrorCode.Unavailable: + return 503; // Service Unavailable + case TwirpErrorCode.DataLoss: + return 500; // Internal Server Error + default: + return 0; // Invalid! + } +} +exports.httpStatusFromErrorCode = httpStatusFromErrorCode; +// IsValidErrorCode returns true if is one of the valid predefined constants. +function isValidErrorCode(code) { + return httpStatusFromErrorCode(code) != 0; +} +exports.isValidErrorCode = isValidErrorCode; + + +/***/ }), + +/***/ 6748: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Gateway = exports.Pattern = void 0; +const querystring_1 = __nccwpck_require__(3477); +const dotObject = __importStar(__nccwpck_require__(4365)); +const request_1 = __nccwpck_require__(8347); +const errors_1 = __nccwpck_require__(6647); +const http_client_1 = __nccwpck_require__(4091); +const server_1 = __nccwpck_require__(6604); +var Pattern; +(function (Pattern) { + Pattern["POST"] = "post"; + Pattern["GET"] = "get"; + Pattern["PATCH"] = "patch"; + Pattern["PUT"] = "put"; + Pattern["DELETE"] = "delete"; +})(Pattern = exports.Pattern || (exports.Pattern = {})); +/** + * The Gateway proxies http requests to Twirp Compliant + * handlers + */ +class Gateway { + constructor(routes) { + this.routes = routes; + } + /** + * Middleware that rewrite the current request + * to a Twirp compliant request + */ + twirpRewrite(prefix = "/twirp") { + return (req, resp, next) => { + this.rewrite(req, resp, prefix) + .then(() => next()) + .catch((e) => { + if (e instanceof errors_1.TwirpError) { + if (e.code !== errors_1.TwirpErrorCode.NotFound) { + server_1.writeError(resp, e); + } + else { + next(); + } + } + }); + }; + } + /** + * Rewrite an incoming request to a Twirp compliant request + * @param req + * @param resp + * @param prefix + */ + rewrite(req, resp, prefix = "/twirp") { + return __awaiter(this, void 0, void 0, function* () { + const [match, route] = this.matchRoute(req); + const body = yield this.prepareTwirpBody(req, match, route); + const twirpUrl = `${prefix}/${route.packageName}.${route.serviceName}/${route.methodName}`; + req.url = twirpUrl; + req.originalUrl = twirpUrl; + req.method = "POST"; + req.headers["content-type"] = "application/json"; + req.rawBody = Buffer.from(JSON.stringify(body)); + if (route.responseBodyKey) { + const endFn = resp.end.bind(resp); + resp.end = function (chunk) { + if (resp.statusCode === 200) { + endFn(`{ "${route.responseBodyKey}": ${chunk} }`); + } + else { + endFn(chunk); + } + }; + } + }); + } + /** + * Create a reverse proxy handler to + * proxy http requests to Twirp Compliant handlers + * @param httpClientOption + */ + reverseProxy(httpClientOption) { + const client = http_client_1.NodeHttpRPC(httpClientOption); + return (req, res) => __awaiter(this, void 0, void 0, function* () { + try { + const [match, route] = this.matchRoute(req); + const body = yield this.prepareTwirpBody(req, match, route); + const response = yield client.request(`${route.packageName}.${route.serviceName}`, route.methodName, "application/json", body); + res.statusCode = 200; + res.setHeader("content-type", "application/json"); + let jsonResponse; + if (route.responseBodyKey) { + jsonResponse = JSON.stringify({ [route.responseBodyKey]: response }); + } + else { + jsonResponse = JSON.stringify(response); + } + res.end(jsonResponse); + } + catch (e) { + server_1.writeError(res, e); + } + }); + } + /** + * Prepares twirp body requests using http.google.annotions + * compliant spec + * + * @param req + * @param match + * @param route + * @protected + */ + prepareTwirpBody(req, match, route) { + return __awaiter(this, void 0, void 0, function* () { + const _a = match.params, { query_string } = _a, params = __rest(_a, ["query_string"]); + let requestBody = Object.assign({}, params); + if (query_string && route.bodyKey !== "*") { + const queryParams = this.parseQueryString(query_string); + requestBody = Object.assign(Object.assign({}, queryParams), requestBody); + } + let body = {}; + if (route.bodyKey) { + const data = yield request_1.getRequestData(req); + try { + const jsonBody = JSON.parse(data.toString() || "{}"); + if (route.bodyKey === "*") { + body = jsonBody; + } + else { + body[route.bodyKey] = jsonBody; + } + } + catch (e) { + const msg = "the json request could not be decoded"; + throw new errors_1.TwirpError(errors_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + return Object.assign(Object.assign({}, body), requestBody); + }); + } + /** + * Matches a route + * @param req + */ + matchRoute(req) { + var _a; + const httpMethod = (_a = req.method) === null || _a === void 0 ? void 0 : _a.toLowerCase(); + if (!httpMethod) { + throw new errors_1.BadRouteError(`method not allowed`, req.method || "", req.url || ""); + } + const routes = this.routes[httpMethod]; + for (const route of routes) { + const match = route.matcher(req.url || "/"); + if (match) { + return [match, route]; + } + } + throw new errors_1.NotFoundError(`url ${req.url} not found`); + } + /** + * Parse query string + * @param queryString + */ + parseQueryString(queryString) { + const queryParams = querystring_1.parse(queryString.replace("?", "")); + return dotObject.object(queryParams); + } +} +exports.Gateway = Gateway; + + +/***/ }), + +/***/ 4263: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isHook = exports.chainHooks = void 0; +// ChainHooks creates a new ServerHook which chains the callbacks in +// each of the constituent hooks passed in. Each hook function will be +// called in the order of the ServerHooks values passed in. +// +// For the erroring hooks, RequestReceived and RequestRouted, any returned +// errors prevent processing by later hooks. +function chainHooks(...hooks) { + if (hooks.length === 0) { + return null; + } + if (hooks.length === 1) { + return hooks[0]; + } + const serverHook = { + requestReceived(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestReceived) { + continue; + } + yield hook.requestReceived(ctx); + } + }); + }, + requestPrepared(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestPrepared) { + continue; + } + console.warn("hook requestPrepared is deprecated and will be removed in the next release. " + + "Please use responsePrepared instead."); + yield hook.requestPrepared(ctx); + } + }); + }, + responsePrepared(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.responsePrepared) { + continue; + } + yield hook.responsePrepared(ctx); + } + }); + }, + requestSent(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestSent) { + continue; + } + console.warn("hook requestSent is deprecated and will be removed in the next release. " + + "Please use responseSent instead."); + yield hook.requestSent(ctx); + } + }); + }, + responseSent(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.responseSent) { + continue; + } + yield hook.responseSent(ctx); + } + }); + }, + requestRouted(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestRouted) { + continue; + } + yield hook.requestRouted(ctx); + } + }); + }, + error(ctx, err) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.error) { + continue; + } + yield hook.error(ctx, err); + } + }); + }, + }; + return serverHook; +} +exports.chainHooks = chainHooks; +function isHook(object) { + return ("requestReceived" in object || + "requestPrepared" in object || + "requestSent" in object || + "requestRouted" in object || + "responsePrepared" in object || + "responseSent" in object || + "error" in object); +} +exports.isHook = isHook; + + +/***/ }), + +/***/ 4091: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.FetchRPC = exports.wrapErrorResponseToTwirpError = exports.NodeHttpRPC = void 0; +const http = __importStar(__nccwpck_require__(3685)); +const https = __importStar(__nccwpck_require__(5687)); +const url_1 = __nccwpck_require__(7310); +const errors_1 = __nccwpck_require__(6647); +/** + * a node HTTP RPC implementation + * @param options + * @constructor + */ +const NodeHttpRPC = (options) => ({ + request(service, method, contentType, data) { + let client; + return new Promise((resolve, rejected) => { + const responseChunks = []; + const requestData = contentType === "application/protobuf" + ? Buffer.from(data) + : JSON.stringify(data); + const url = new url_1.URL(options.baseUrl); + const isHttps = url.protocol === "https:"; + if (isHttps) { + client = https; + } + else { + client = http; + } + const prefix = url.pathname !== "/" ? url.pathname : ""; + const req = client + .request(Object.assign(Object.assign({}, (options ? options : {})), { method: "POST", protocol: url.protocol, host: url.hostname, port: url.port ? url.port : isHttps ? 443 : 80, path: `${prefix}/${service}/${method}`, headers: Object.assign(Object.assign({}, (options.headers ? options.headers : {})), { "Content-Type": contentType, "Content-Length": contentType === "application/protobuf" + ? Buffer.byteLength(requestData) + : Buffer.from(requestData).byteLength }) }), (res) => { + res.on("data", (chunk) => responseChunks.push(chunk)); + res.on("end", () => { + const data = Buffer.concat(responseChunks); + if (res.statusCode != 200) { + rejected(wrapErrorResponseToTwirpError(data.toString())); + } + else { + if (contentType === "application/json") { + resolve(JSON.parse(data.toString())); + } + else { + resolve(data); + } + } + }); + res.on("error", (err) => { + rejected(err); + }); + }) + .on("error", (err) => { + rejected(err); + }); + req.end(requestData); + }); + }, +}); +exports.NodeHttpRPC = NodeHttpRPC; +function wrapErrorResponseToTwirpError(errorResponse) { + return errors_1.TwirpError.fromObject(JSON.parse(errorResponse)); +} +exports.wrapErrorResponseToTwirpError = wrapErrorResponseToTwirpError; +/** + * a browser fetch RPC implementation + */ +const FetchRPC = (options) => ({ + request(service, method, contentType, data) { + return __awaiter(this, void 0, void 0, function* () { + const headers = new Headers(options.headers); + headers.set("content-type", contentType); + const response = yield fetch(`${options.baseUrl}/${service}/${method}`, Object.assign(Object.assign({}, options), { method: "POST", headers, body: data instanceof Uint8Array ? data : JSON.stringify(data) })); + if (response.status === 200) { + if (contentType === "application/json") { + return yield response.json(); + } + return new Uint8Array(yield response.arrayBuffer()); + } + throw errors_1.TwirpError.fromObject(yield response.json()); + }); + }, +}); +exports.FetchRPC = FetchRPC; + + +/***/ }), + +/***/ 6465: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TwirpContentType = void 0; +__exportStar(__nccwpck_require__(1524), exports); +__exportStar(__nccwpck_require__(6604), exports); +__exportStar(__nccwpck_require__(8913), exports); +__exportStar(__nccwpck_require__(4263), exports); +__exportStar(__nccwpck_require__(6647), exports); +__exportStar(__nccwpck_require__(6748), exports); +__exportStar(__nccwpck_require__(4091), exports); +var request_1 = __nccwpck_require__(8347); +Object.defineProperty(exports, "TwirpContentType", ({ enumerable: true, get: function () { return request_1.TwirpContentType; } })); + + +/***/ }), + +/***/ 8913: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.chainInterceptors = void 0; +// chains multiple Interceptors into a single Interceptor. +// The first interceptor wraps the second one, and so on. +// Returns null if interceptors is empty. +function chainInterceptors(...interceptors) { + if (interceptors.length === 0) { + return; + } + if (interceptors.length === 1) { + return interceptors[0]; + } + const first = interceptors[0]; + return (ctx, request, handler) => __awaiter(this, void 0, void 0, function* () { + let next = handler; + for (let i = interceptors.length - 1; i > 0; i--) { + next = ((next) => (ctx, typedRequest) => { + return interceptors[i](ctx, typedRequest, next); + })(next); + } + return first(ctx, request, next); + }); +} +exports.chainInterceptors = chainInterceptors; + + +/***/ }), + +/***/ 8347: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.parseTwirpPath = exports.getRequestData = exports.validateRequest = exports.getContentType = exports.TwirpContentType = void 0; +const errors_1 = __nccwpck_require__(6647); +/** + * Supported Twirp Content-Type + */ +var TwirpContentType; +(function (TwirpContentType) { + TwirpContentType[TwirpContentType["Protobuf"] = 0] = "Protobuf"; + TwirpContentType[TwirpContentType["JSON"] = 1] = "JSON"; + TwirpContentType[TwirpContentType["Unknown"] = 2] = "Unknown"; +})(TwirpContentType = exports.TwirpContentType || (exports.TwirpContentType = {})); +/** + * Get supported content-type + * @param mimeType + */ +function getContentType(mimeType) { + switch (mimeType) { + case "application/protobuf": + return TwirpContentType.Protobuf; + case "application/json": + return TwirpContentType.JSON; + default: + return TwirpContentType.Unknown; + } +} +exports.getContentType = getContentType; +/** + * Validate a twirp request + * @param ctx + * @param request + * @param pathPrefix + */ +function validateRequest(ctx, request, pathPrefix) { + if (request.method !== "POST") { + const msg = `unsupported method ${request.method} (only POST is allowed)`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + const path = parseTwirpPath(request.url || ""); + if (path.pkgService !== + (ctx.packageName ? ctx.packageName + "." : "") + ctx.serviceName) { + const msg = `no handler for path ${request.url}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + if (path.prefix !== pathPrefix) { + const msg = `invalid path prefix ${path.prefix}, expected ${pathPrefix}, on path ${request.url}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + const mimeContentType = request.headers["content-type"] || ""; + if (ctx.contentType === TwirpContentType.Unknown) { + const msg = `unexpected Content-Type: ${request.headers["content-type"]}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + return Object.assign(Object.assign({}, path), { mimeContentType, contentType: ctx.contentType }); +} +exports.validateRequest = validateRequest; +/** + * Get request data from the body + * @param req + */ +function getRequestData(req) { + return new Promise((resolve, reject) => { + const reqWithRawBody = req; + if (reqWithRawBody.rawBody instanceof Buffer) { + resolve(reqWithRawBody.rawBody); + return; + } + const chunks = []; + req.on("data", (chunk) => chunks.push(chunk)); + req.on("end", () => __awaiter(this, void 0, void 0, function* () { + const data = Buffer.concat(chunks); + resolve(data); + })); + req.on("error", (err) => { + if (req.aborted) { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.DeadlineExceeded, "failed to read request: deadline exceeded")); + } + else { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.Malformed, err.message).withCause(err)); + } + }); + req.on("close", () => { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.Canceled, "failed to read request: context canceled")); + }); + }); +} +exports.getRequestData = getRequestData; +/** + * Parses twirp url path + * @param path + */ +function parseTwirpPath(path) { + const parts = path.split("/"); + if (parts.length < 2) { + return { + pkgService: "", + method: "", + prefix: "", + }; + } + return { + method: parts[parts.length - 1], + pkgService: parts[parts.length - 2], + prefix: parts.slice(0, parts.length - 2).join("/"), + }; +} +exports.parseTwirpPath = parseTwirpPath; + + +/***/ }), + +/***/ 6604: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.writeError = exports.TwirpServer = void 0; +const hooks_1 = __nccwpck_require__(4263); +const request_1 = __nccwpck_require__(8347); +const errors_1 = __nccwpck_require__(6647); +/** + * Runtime server implementation of a TwirpServer + */ +class TwirpServer { + constructor(options) { + this.pathPrefix = "/twirp"; + this.hooks = []; + this.interceptors = []; + this.packageName = options.packageName; + this.serviceName = options.serviceName; + this.methodList = options.methodList; + this.matchRoute = options.matchRoute; + this.service = options.service; + } + /** + * Returns the prefix for this server + */ + get prefix() { + return this.pathPrefix; + } + /** + * The http handler for twirp complaint endpoints + * @param options + */ + httpHandler(options) { + return (req, resp) => { + // setup prefix + if ((options === null || options === void 0 ? void 0 : options.prefix) !== undefined) { + this.withPrefix(options.prefix); + } + return this._httpHandler(req, resp); + }; + } + /** + * Adds interceptors or hooks to the request stack + * @param middlewares + */ + use(...middlewares) { + middlewares.forEach((middleware) => { + if (hooks_1.isHook(middleware)) { + this.hooks.push(middleware); + return this; + } + this.interceptors.push(middleware); + }); + return this; + } + /** + * Adds a prefix to the service url path + * @param prefix + */ + withPrefix(prefix) { + if (prefix === false) { + this.pathPrefix = ""; + } + else { + this.pathPrefix = prefix; + } + return this; + } + /** + * Returns the regex matching path for this twirp server + */ + matchingPath() { + const baseRegex = this.baseURI().replace(/\./g, "\\."); + return new RegExp(`${baseRegex}\/(${this.methodList.join("|")})`); + } + /** + * Returns the base URI for this twirp server + */ + baseURI() { + return `${this.pathPrefix}/${this.packageName ? this.packageName + "." : ""}${this.serviceName}`; + } + /** + * Create a twirp context + * @param req + * @param res + * @private + */ + createContext(req, res) { + return { + packageName: this.packageName, + serviceName: this.serviceName, + methodName: "", + contentType: request_1.getContentType(req.headers["content-type"]), + req: req, + res: res, + }; + } + /** + * Twrip server http handler implementation + * @param req + * @param resp + * @private + */ + _httpHandler(req, resp) { + return __awaiter(this, void 0, void 0, function* () { + const ctx = this.createContext(req, resp); + try { + yield this.invokeHook("requestReceived", ctx); + const { method, mimeContentType } = request_1.validateRequest(ctx, req, this.pathPrefix || ""); + const handler = this.matchRoute(method, { + onMatch: (ctx) => { + return this.invokeHook("requestRouted", ctx); + }, + onNotFound: () => { + const msg = `no handler for path ${req.url}`; + throw new errors_1.BadRouteError(msg, req.method || "", req.url || ""); + }, + }); + const body = yield request_1.getRequestData(req); + const response = yield handler(ctx, this.service, body, this.interceptors); + yield Promise.all([ + this.invokeHook("responsePrepared", ctx), + // keep backwards compatibility till next release + this.invokeHook("requestPrepared", ctx), + ]); + resp.statusCode = 200; + resp.setHeader("Content-Type", mimeContentType); + resp.end(response); + } + catch (e) { + yield this.invokeHook("error", ctx, mustBeTwirpError(e)); + if (!resp.headersSent) { + writeError(resp, e); + } + } + finally { + yield Promise.all([ + this.invokeHook("responseSent", ctx), + // keep backwards compatibility till next release + this.invokeHook("requestSent", ctx), + ]); + } + }); + } + /** + * Invoke a hook + * @param hookName + * @param ctx + * @param err + * @protected + */ + invokeHook(hookName, ctx, err) { + return __awaiter(this, void 0, void 0, function* () { + if (this.hooks.length === 0) { + return; + } + const chainedHooks = hooks_1.chainHooks(...this.hooks); + const hook = chainedHooks === null || chainedHooks === void 0 ? void 0 : chainedHooks[hookName]; + if (hook) { + yield hook(ctx, err || new errors_1.InternalServerError("internal server error")); + } + }); + } +} +exports.TwirpServer = TwirpServer; +/** + * Write http error response + * @param res + * @param error + */ +function writeError(res, error) { + const twirpError = mustBeTwirpError(error); + res.setHeader("Content-Type", "application/json"); + res.statusCode = errors_1.httpStatusFromErrorCode(twirpError.code); + res.end(twirpError.toJSON()); +} +exports.writeError = writeError; +/** + * Make sure that the error passed is a TwirpError + * otherwise it will wrap it into an InternalError + * @param err + */ +function mustBeTwirpError(err) { + if (err instanceof errors_1.TwirpError) { + return err; + } + return new errors_1.InternalServerErrorWith(err); +} + + /***/ }), /***/ 1773: @@ -58537,7 +67155,7 @@ class Request { } if (!extractBody) { - extractBody = (__nccwpck_require__(9990).extractBody) + extractBody = (__nccwpck_require__(1472).extractBody) } const [bodyStream, contentType] = extractBody(body) @@ -59664,7 +68282,7 @@ module.exports = Dispatcher /***/ }), -/***/ 9990: +/***/ 1472: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -62390,7 +71008,7 @@ const { } = __nccwpck_require__(2538) const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(5861) const assert = __nccwpck_require__(9491) -const { safelyExtractBody } = __nccwpck_require__(9990) +const { safelyExtractBody } = __nccwpck_require__(1472) const { redirectStatusSet, nullBodyStatus, @@ -64504,7 +73122,7 @@ module.exports = { -const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(9990) +const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(1472) const { Headers, fill: fillHeaders, HeadersList } = __nccwpck_require__(554) const { FinalizationRegistry } = __nccwpck_require__(6436)() const util = __nccwpck_require__(3983) @@ -65457,7 +74075,7 @@ module.exports = { Request, makeRequest } const { Headers, HeadersList, fill } = __nccwpck_require__(554) -const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(9990) +const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(1472) const util = __nccwpck_require__(3983) const { kEnumerableProperty } = util const { @@ -73790,221 +82408,6 @@ module.exports = { } -/***/ }), - -/***/ 2155: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var v1 = __nccwpck_require__(8749); -var v4 = __nccwpck_require__(824); - -var uuid = v4; -uuid.v1 = v1; -uuid.v4 = v4; - -module.exports = uuid; - - -/***/ }), - -/***/ 2707: -/***/ ((module) => { - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -var byteToHex = []; -for (var i = 0; i < 256; ++i) { - byteToHex[i] = (i + 0x100).toString(16).substr(1); -} - -function bytesToUuid(buf, offset) { - var i = offset || 0; - var bth = byteToHex; - // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4 - return ([ - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], '-', - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]], - bth[buf[i++]], bth[buf[i++]] - ]).join(''); -} - -module.exports = bytesToUuid; - - -/***/ }), - -/***/ 5859: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -// Unique ID creation requires a high quality random # generator. In node.js -// this is pretty straight-forward - we use the crypto API. - -var crypto = __nccwpck_require__(6113); - -module.exports = function nodeRNG() { - return crypto.randomBytes(16); -}; - - -/***/ }), - -/***/ 8749: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var rng = __nccwpck_require__(5859); -var bytesToUuid = __nccwpck_require__(2707); - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -var _nodeId; -var _clockseq; - -// Previous uuid creation time -var _lastMSecs = 0; -var _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details -function v1(options, buf, offset) { - var i = buf && offset || 0; - var b = buf || []; - - options = options || {}; - var node = options.node || _nodeId; - var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; - - // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - if (node == null || clockseq == null) { - var seedBytes = rng(); - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [ - seedBytes[0] | 0x01, - seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5] - ]; - } - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - } - } - - // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec'); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (var n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf ? buf : bytesToUuid(b); -} - -module.exports = v1; - - -/***/ }), - -/***/ 824: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var rng = __nccwpck_require__(5859); -var bytesToUuid = __nccwpck_require__(2707); - -function v4(options, buf, offset) { - var i = buf && offset || 0; - - if (typeof(options) == 'string') { - buf = options === 'binary' ? new Array(16) : null; - options = null; - } - options = options || {}; - - var rnds = options.random || (options.rng || rng)(); - - // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - rnds[6] = (rnds[6] & 0x0f) | 0x40; - rnds[8] = (rnds[8] & 0x3f) | 0x80; - - // Copy bytes to buffer, if provided - if (buf) { - for (var ii = 0; ii < 16; ++ii) { - buf[i + ii] = rnds[ii]; - } - } - - return buf || bytesToUuid(rnds); -} - -module.exports = v4; - - /***/ }), /***/ 4886: @@ -83077,6 +91480,14 @@ function parseParams (str) { module.exports = parseParams +/***/ }), + +/***/ 9167: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse('{"name":"@actions/cache","version":"4.0.0","preview":true,"description":"Actions cache lib","keywords":["github","actions","cache"],"homepage":"https://github.com/actions/toolkit/tree/main/packages/cache","license":"MIT","main":"lib/cache.js","types":"lib/cache.d.ts","directories":{"lib":"lib","test":"__tests__"},"files":["lib","!.DS_Store"],"publishConfig":{"access":"public"},"repository":{"type":"git","url":"git+https://github.com/actions/toolkit.git","directory":"packages/cache"},"scripts":{"audit-moderate":"npm install && npm audit --json --audit-level=moderate > audit.json","test":"echo \\"Error: run tests from root\\" && exit 1","tsc":"tsc"},"bugs":{"url":"https://github.com/actions/toolkit/issues"},"dependencies":{"@actions/core":"^1.11.1","@actions/exec":"^1.0.1","@actions/glob":"^0.1.0","@actions/http-client":"^2.1.1","@actions/io":"^1.0.1","@azure/abort-controller":"^1.1.0","@azure/ms-rest-js":"^2.6.0","@azure/storage-blob":"^12.13.0","@protobuf-ts/plugin":"^2.9.4","semver":"^6.3.1","twirp-ts":"^2.5.0"},"devDependencies":{"@types/semver":"^6.0.0","typescript":"^5.2.2"}}'); + /***/ }), /***/ 3765: diff --git a/dist/setup/index.js b/dist/setup/index.js index e56f966..42b5277 100644 --- a/dist/setup/index.js +++ b/dist/setup/index.js @@ -44,7 +44,10 @@ const core = __importStar(__nccwpck_require__(2186)); const path = __importStar(__nccwpck_require__(1017)); const utils = __importStar(__nccwpck_require__(1518)); const cacheHttpClient = __importStar(__nccwpck_require__(8245)); +const cacheTwirpClient = __importStar(__nccwpck_require__(2502)); +const config_1 = __nccwpck_require__(5147); const tar_1 = __nccwpck_require__(6490); +const constants_1 = __nccwpck_require__(8840); class ValidationError extends Error { constructor(message) { super(message); @@ -88,15 +91,39 @@ exports.isFeatureAvailable = isFeatureAvailable; * Restores cache from keys * * @param paths a list of file paths to restore from the cache - * @param primaryKey an explicit key for restoring the cache - * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for key + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching. + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey * @param downloadOptions cache download options * @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform * @returns string returns the key for the cache hit, otherwise returns undefined */ function restoreCache(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { return __awaiter(this, void 0, void 0, function* () { + const cacheServiceVersion = (0, config_1.getCacheServiceVersion)(); + core.debug(`Cache service version: ${cacheServiceVersion}`); checkPaths(paths); + switch (cacheServiceVersion) { + case 'v2': + return yield restoreCacheV2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive); + case 'v1': + default: + return yield restoreCacheV1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive); + } + }); +} +exports.restoreCache = restoreCache; +/** + * Restores cache using the legacy Cache Service + * + * @param paths a list of file paths to restore from the cache + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching. + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey + * @param options cache download options + * @param enableCrossOsArchive an optional boolean enabled to restore on Windows any cache created on any platform + * @returns string returns the key for the cache hit, otherwise returns undefined + */ +function restoreCacheV1(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { restoreKeys = restoreKeys || []; const keys = [primaryKey, ...restoreKeys]; core.debug('Resolved Keys:'); @@ -158,7 +185,85 @@ function restoreCache(paths, primaryKey, restoreKeys, options, enableCrossOsArch return undefined; }); } -exports.restoreCache = restoreCache; +/** + * Restores cache using Cache Service v2 + * + * @param paths a list of file paths to restore from the cache + * @param primaryKey an explicit key for restoring the cache. Lookup is done with prefix matching + * @param restoreKeys an optional ordered list of keys to use for restoring the cache if no cache hit occurred for primaryKey + * @param downloadOptions cache download options + * @param enableCrossOsArchive an optional boolean enabled to restore on windows any cache created on any platform + * @returns string returns the key for the cache hit, otherwise returns undefined + */ +function restoreCacheV2(paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { + // Override UploadOptions to force the use of Azure + options = Object.assign(Object.assign({}, options), { useAzureSdk: true }); + restoreKeys = restoreKeys || []; + const keys = [primaryKey, ...restoreKeys]; + core.debug('Resolved Keys:'); + core.debug(JSON.stringify(keys)); + if (keys.length > 10) { + throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`); + } + for (const key of keys) { + checkKey(key); + } + let archivePath = ''; + try { + const twirpClient = cacheTwirpClient.internalCacheTwirpClient(); + const compressionMethod = yield utils.getCompressionMethod(); + const request = { + key: primaryKey, + restoreKeys, + version: utils.getCacheVersion(paths, compressionMethod, enableCrossOsArchive) + }; + const response = yield twirpClient.GetCacheEntryDownloadURL(request); + if (!response.ok) { + core.warning(`Cache not found for keys: ${keys.join(', ')}`); + return undefined; + } + core.info(`Cache hit for: ${request.key}`); + if (options === null || options === void 0 ? void 0 : options.lookupOnly) { + core.info('Lookup only - skipping download'); + return response.matchedKey; + } + archivePath = path.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod)); + core.debug(`Archive path: ${archivePath}`); + core.debug(`Starting download of archive to: ${archivePath}`); + yield cacheHttpClient.downloadCache(response.signedDownloadUrl, archivePath, options); + const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); + core.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`); + if (core.isDebug()) { + yield (0, tar_1.listTar)(archivePath, compressionMethod); + } + yield (0, tar_1.extractTar)(archivePath, compressionMethod); + core.info('Cache restored successfully'); + return response.matchedKey; + } + catch (error) { + const typedError = error; + if (typedError.name === ValidationError.name) { + throw error; + } + else { + // Supress all non-validation cache related errors because caching should be optional + core.warning(`Failed to restore: ${error.message}`); + } + } + finally { + try { + if (archivePath) { + yield utils.unlinkFile(archivePath); + } + } + catch (error) { + core.debug(`Failed to delete archive: ${error}`); + } + } + return undefined; + }); +} /** * Saves a list of files with the specified key * @@ -169,10 +274,33 @@ exports.restoreCache = restoreCache; * @returns number returns cacheId if the cache was saved successfully and throws an error if save fails */ function saveCache(paths, key, options, enableCrossOsArchive = false) { - var _a, _b, _c, _d, _e; return __awaiter(this, void 0, void 0, function* () { + const cacheServiceVersion = (0, config_1.getCacheServiceVersion)(); + core.debug(`Cache service version: ${cacheServiceVersion}`); checkPaths(paths); checkKey(key); + switch (cacheServiceVersion) { + case 'v2': + return yield saveCacheV2(paths, key, options, enableCrossOsArchive); + case 'v1': + default: + return yield saveCacheV1(paths, key, options, enableCrossOsArchive); + } + }); +} +exports.saveCache = saveCache; +/** + * Save cache using the legacy Cache Service + * + * @param paths + * @param key + * @param options + * @param enableCrossOsArchive + * @returns + */ +function saveCacheV1(paths, key, options, enableCrossOsArchive = false) { + var _a, _b, _c, _d, _e; + return __awaiter(this, void 0, void 0, function* () { const compressionMethod = yield utils.getCompressionMethod(); let cacheId = -1; const cachePaths = yield utils.resolvePaths(paths); @@ -193,7 +321,7 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); core.debug(`File Size: ${archiveFileSize}`); // For GHES, this check will take place in ReserveCache API with enterprise file size limit - if (archiveFileSize > fileSizeLimit && !utils.isGhes()) { + if (archiveFileSize > fileSizeLimit && !(0, config_1.isGhes)()) { throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`); } core.debug('Reserving Cache'); @@ -212,7 +340,95 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message}`); } core.debug(`Saving Cache (ID: ${cacheId})`); - yield cacheHttpClient.saveCache(cacheId, archivePath, options); + yield cacheHttpClient.saveCache(cacheId, archivePath, '', options); + } + catch (error) { + const typedError = error; + if (typedError.name === ValidationError.name) { + throw error; + } + else if (typedError.name === ReserveCacheError.name) { + core.info(`Failed to save: ${typedError.message}`); + } + else { + core.warning(`Failed to save: ${typedError.message}`); + } + } + finally { + // Try to delete the archive to save space + try { + yield utils.unlinkFile(archivePath); + } + catch (error) { + core.debug(`Failed to delete archive: ${error}`); + } + } + return cacheId; + }); +} +/** + * Save cache using Cache Service v2 + * + * @param paths a list of file paths to restore from the cache + * @param key an explicit key for restoring the cache + * @param options cache upload options + * @param enableCrossOsArchive an optional boolean enabled to save cache on windows which could be restored on any platform + * @returns + */ +function saveCacheV2(paths, key, options, enableCrossOsArchive = false) { + return __awaiter(this, void 0, void 0, function* () { + // Override UploadOptions to force the use of Azure + // ...options goes first because we want to override the default values + // set in UploadOptions with these specific figures + options = Object.assign(Object.assign({}, options), { uploadChunkSize: 64 * 1024 * 1024, uploadConcurrency: 8, useAzureSdk: true }); + const compressionMethod = yield utils.getCompressionMethod(); + const twirpClient = cacheTwirpClient.internalCacheTwirpClient(); + let cacheId = -1; + const cachePaths = yield utils.resolvePaths(paths); + core.debug('Cache Paths:'); + core.debug(`${JSON.stringify(cachePaths)}`); + if (cachePaths.length === 0) { + throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`); + } + const archiveFolder = yield utils.createTempDirectory(); + const archivePath = path.join(archiveFolder, utils.getCacheFileName(compressionMethod)); + core.debug(`Archive Path: ${archivePath}`); + try { + yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod); + if (core.isDebug()) { + yield (0, tar_1.listTar)(archivePath, compressionMethod); + } + const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath); + core.debug(`File Size: ${archiveFileSize}`); + // For GHES, this check will take place in ReserveCache API with enterprise file size limit + if (archiveFileSize > constants_1.CacheFileSizeLimit && !(0, config_1.isGhes)()) { + throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`); + } + // Set the archive size in the options, will be used to display the upload progress + options.archiveSizeBytes = archiveFileSize; + core.debug('Reserving Cache'); + const version = utils.getCacheVersion(paths, compressionMethod, enableCrossOsArchive); + const request = { + key, + version + }; + const response = yield twirpClient.CreateCacheEntry(request); + if (!response.ok) { + throw new ReserveCacheError(`Unable to reserve cache with key ${key}, another job may be creating this cache.`); + } + core.debug(`Attempting to upload cache located at: ${archivePath}`); + yield cacheHttpClient.saveCache(cacheId, archivePath, response.signedUploadUrl, options); + const finalizeRequest = { + key, + version, + sizeBytes: `${archiveFileSize}` + }; + const finalizeResponse = yield twirpClient.FinalizeCacheEntryUpload(finalizeRequest); + core.debug(`FinalizeCacheEntryUploadResponse: ${finalizeResponse.ok}`); + if (!finalizeResponse.ok) { + throw new Error(`Unable to finalize cache with key ${key}, another job may be finalizing this cache.`); + } + cacheId = parseInt(finalizeResponse.entryId); } catch (error) { const typedError = error; @@ -238,11 +454,1753 @@ function saveCache(paths, key, options, enableCrossOsArchive = false) { return cacheId; }); } -exports.saveCache = saveCache; //# sourceMappingURL=cache.js.map /***/ }), +/***/ 4469: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Timestamp = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const runtime_6 = __nccwpck_require__(4061); +const runtime_7 = __nccwpck_require__(4061); +// @generated message type with reflection information, may provide speed optimized methods +class Timestamp$Type extends runtime_7.MessageType { + constructor() { + super("google.protobuf.Timestamp", [ + { no: 1, name: "seconds", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 2, name: "nanos", kind: "scalar", T: 5 /*ScalarType.INT32*/ } + ]); + } + /** + * Creates a new `Timestamp` for the current time. + */ + now() { + const msg = this.create(); + const ms = Date.now(); + msg.seconds = runtime_6.PbLong.from(Math.floor(ms / 1000)).toString(); + msg.nanos = (ms % 1000) * 1000000; + return msg; + } + /** + * Converts a `Timestamp` to a JavaScript Date. + */ + toDate(message) { + return new Date(runtime_6.PbLong.from(message.seconds).toNumber() * 1000 + Math.ceil(message.nanos / 1000000)); + } + /** + * Converts a JavaScript Date to a `Timestamp`. + */ + fromDate(date) { + const msg = this.create(); + const ms = date.getTime(); + msg.seconds = runtime_6.PbLong.from(Math.floor(ms / 1000)).toString(); + msg.nanos = (ms % 1000) * 1000000; + return msg; + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonWrite(message, options) { + let ms = runtime_6.PbLong.from(message.seconds).toNumber() * 1000; + if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) + throw new Error("Unable to encode Timestamp to JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."); + if (message.nanos < 0) + throw new Error("Unable to encode invalid Timestamp to JSON. Nanos must not be negative."); + let z = "Z"; + if (message.nanos > 0) { + let nanosStr = (message.nanos + 1000000000).toString().substring(1); + if (nanosStr.substring(3) === "000000") + z = "." + nanosStr.substring(0, 3) + "Z"; + else if (nanosStr.substring(6) === "000") + z = "." + nanosStr.substring(0, 6) + "Z"; + else + z = "." + nanosStr + "Z"; + } + return new Date(ms).toISOString().replace(".000Z", z); + } + /** + * In JSON format, the `Timestamp` type is encoded as a string + * in the RFC 3339 format. + */ + internalJsonRead(json, options, target) { + if (typeof json !== "string") + throw new Error("Unable to parse Timestamp from JSON " + (0, runtime_5.typeofJsonValue)(json) + "."); + let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/); + if (!matches) + throw new Error("Unable to parse Timestamp from JSON. Invalid format."); + let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z")); + if (Number.isNaN(ms)) + throw new Error("Unable to parse Timestamp from JSON. Invalid value."); + if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) + throw new globalThis.Error("Unable to parse Timestamp from JSON. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive."); + if (!target) + target = this.create(); + target.seconds = runtime_6.PbLong.from(ms / 1000).toString(); + target.nanos = 0; + if (matches[7]) + target.nanos = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000); + return target; + } + create(value) { + const message = { seconds: "0", nanos: 0 }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 seconds */ 1: + message.seconds = reader.int64().toString(); + break; + case /* int32 nanos */ 2: + message.nanos = reader.int32(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int64 seconds = 1; */ + if (message.seconds !== "0") + writer.tag(1, runtime_1.WireType.Varint).int64(message.seconds); + /* int32 nanos = 2; */ + if (message.nanos !== 0) + writer.tag(2, runtime_1.WireType.Varint).int32(message.nanos); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message google.protobuf.Timestamp + */ +exports.Timestamp = new Timestamp$Type(); +//# sourceMappingURL=timestamp.js.map + +/***/ }), + +/***/ 4388: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheService = exports.LookupCacheEntryResponse = exports.LookupCacheEntryRequest = exports.ListCacheEntriesResponse = exports.ListCacheEntriesRequest = exports.DeleteCacheEntryResponse = exports.DeleteCacheEntryRequest = exports.GetCacheEntryDownloadURLResponse = exports.GetCacheEntryDownloadURLRequest = exports.FinalizeCacheEntryUploadResponse = exports.FinalizeCacheEntryUploadRequest = exports.CreateCacheEntryResponse = exports.CreateCacheEntryRequest = void 0; +// @generated by protobuf-ts 2.9.1 with parameter long_type_string,client_none,generate_dependencies +// @generated from protobuf file "results/api/v1/cache.proto" (package "github.actions.results.api.v1", syntax proto3) +// tslint:disable +const runtime_rpc_1 = __nccwpck_require__(12); +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const cacheentry_1 = __nccwpck_require__(3639); +const cachemetadata_1 = __nccwpck_require__(7988); +// @generated message type with reflection information, may provide speed optimized methods +class CreateCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.CreateCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* string version */ 3: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* string version = 3; */ + if (message.version !== "") + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryRequest + */ +exports.CreateCacheEntryRequest = new CreateCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class CreateCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.CreateCacheEntryResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "signed_upload_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { ok: false, signedUploadUrl: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* string signed_upload_url */ 2: + message.signedUploadUrl = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* string signed_upload_url = 2; */ + if (message.signedUploadUrl !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.signedUploadUrl); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.CreateCacheEntryResponse + */ +exports.CreateCacheEntryResponse = new CreateCacheEntryResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FinalizeCacheEntryUploadRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.FinalizeCacheEntryUploadRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "size_bytes", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", sizeBytes: "0", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* int64 size_bytes */ 3: + message.sizeBytes = reader.int64().toString(); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* int64 size_bytes = 3; */ + if (message.sizeBytes !== "0") + writer.tag(3, runtime_1.WireType.Varint).int64(message.sizeBytes); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadRequest + */ +exports.FinalizeCacheEntryUploadRequest = new FinalizeCacheEntryUploadRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class FinalizeCacheEntryUploadResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.FinalizeCacheEntryUploadResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { ok: false, entryId: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* int64 entry_id */ 2: + message.entryId = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* int64 entry_id = 2; */ + if (message.entryId !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.entryId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.FinalizeCacheEntryUploadResponse + */ +exports.FinalizeCacheEntryUploadResponse = new FinalizeCacheEntryUploadResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetCacheEntryDownloadURLRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.GetCacheEntryDownloadURLRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [], version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLRequest + */ +exports.GetCacheEntryDownloadURLRequest = new GetCacheEntryDownloadURLRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class GetCacheEntryDownloadURLResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.GetCacheEntryDownloadURLResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "signed_download_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "matched_key", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { ok: false, signedDownloadUrl: "", matchedKey: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* string signed_download_url */ 2: + message.signedDownloadUrl = reader.string(); + break; + case /* string matched_key */ 3: + message.matchedKey = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* string signed_download_url = 2; */ + if (message.signedDownloadUrl !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.signedDownloadUrl); + /* string matched_key = 3; */ + if (message.matchedKey !== "") + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.matchedKey); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.GetCacheEntryDownloadURLResponse + */ +exports.GetCacheEntryDownloadURLResponse = new GetCacheEntryDownloadURLResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DeleteCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.DeleteCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.DeleteCacheEntryRequest + */ +exports.DeleteCacheEntryRequest = new DeleteCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class DeleteCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.DeleteCacheEntryResponse", [ + { no: 1, name: "ok", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { ok: false, entryId: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool ok */ 1: + message.ok = reader.bool(); + break; + case /* int64 entry_id */ 2: + message.entryId = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool ok = 1; */ + if (message.ok !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.ok); + /* int64 entry_id = 2; */ + if (message.entryId !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.entryId); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.DeleteCacheEntryResponse + */ +exports.DeleteCacheEntryResponse = new DeleteCacheEntryResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ListCacheEntriesRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.ListCacheEntriesRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.ListCacheEntriesRequest + */ +exports.ListCacheEntriesRequest = new ListCacheEntriesRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class ListCacheEntriesResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.ListCacheEntriesResponse", [ + { no: 1, name: "entries", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => cacheentry_1.CacheEntry } + ]); + } + create(value) { + const message = { entries: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* repeated github.actions.results.entities.v1.CacheEntry entries */ 1: + message.entries.push(cacheentry_1.CacheEntry.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* repeated github.actions.results.entities.v1.CacheEntry entries = 1; */ + for (let i = 0; i < message.entries.length; i++) + cacheentry_1.CacheEntry.internalBinaryWrite(message.entries[i], writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.ListCacheEntriesResponse + */ +exports.ListCacheEntriesResponse = new ListCacheEntriesResponse$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class LookupCacheEntryRequest$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.LookupCacheEntryRequest", [ + { no: 1, name: "metadata", kind: "message", T: () => cachemetadata_1.CacheMetadata }, + { no: 2, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "restore_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }, + { no: 4, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ } + ]); + } + create(value) { + const message = { key: "", restoreKeys: [], version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* github.actions.results.entities.v1.CacheMetadata metadata */ 1: + message.metadata = cachemetadata_1.CacheMetadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata); + break; + case /* string key */ 2: + message.key = reader.string(); + break; + case /* repeated string restore_keys */ 3: + message.restoreKeys.push(reader.string()); + break; + case /* string version */ 4: + message.version = reader.string(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* github.actions.results.entities.v1.CacheMetadata metadata = 1; */ + if (message.metadata) + cachemetadata_1.CacheMetadata.internalBinaryWrite(message.metadata, writer.tag(1, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* string key = 2; */ + if (message.key !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.key); + /* repeated string restore_keys = 3; */ + for (let i = 0; i < message.restoreKeys.length; i++) + writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.restoreKeys[i]); + /* string version = 4; */ + if (message.version !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.version); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.LookupCacheEntryRequest + */ +exports.LookupCacheEntryRequest = new LookupCacheEntryRequest$Type(); +// @generated message type with reflection information, may provide speed optimized methods +class LookupCacheEntryResponse$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.api.v1.LookupCacheEntryResponse", [ + { no: 1, name: "exists", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }, + { no: 2, name: "entry", kind: "message", T: () => cacheentry_1.CacheEntry } + ]); + } + create(value) { + const message = { exists: false }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* bool exists */ 1: + message.exists = reader.bool(); + break; + case /* github.actions.results.entities.v1.CacheEntry entry */ 2: + message.entry = cacheentry_1.CacheEntry.internalBinaryRead(reader, reader.uint32(), options, message.entry); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* bool exists = 1; */ + if (message.exists !== false) + writer.tag(1, runtime_1.WireType.Varint).bool(message.exists); + /* github.actions.results.entities.v1.CacheEntry entry = 2; */ + if (message.entry) + cacheentry_1.CacheEntry.internalBinaryWrite(message.entry, writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.api.v1.LookupCacheEntryResponse + */ +exports.LookupCacheEntryResponse = new LookupCacheEntryResponse$Type(); +/** + * @generated ServiceType for protobuf service github.actions.results.api.v1.CacheService + */ +exports.CacheService = new runtime_rpc_1.ServiceType("github.actions.results.api.v1.CacheService", [ + { name: "CreateCacheEntry", options: {}, I: exports.CreateCacheEntryRequest, O: exports.CreateCacheEntryResponse }, + { name: "FinalizeCacheEntryUpload", options: {}, I: exports.FinalizeCacheEntryUploadRequest, O: exports.FinalizeCacheEntryUploadResponse }, + { name: "GetCacheEntryDownloadURL", options: {}, I: exports.GetCacheEntryDownloadURLRequest, O: exports.GetCacheEntryDownloadURLResponse }, + { name: "DeleteCacheEntry", options: {}, I: exports.DeleteCacheEntryRequest, O: exports.DeleteCacheEntryResponse }, + { name: "ListCacheEntries", options: {}, I: exports.ListCacheEntriesRequest, O: exports.ListCacheEntriesResponse }, + { name: "LookupCacheEntry", options: {}, I: exports.LookupCacheEntryRequest, O: exports.LookupCacheEntryResponse } +]); +//# sourceMappingURL=cache.js.map + +/***/ }), + +/***/ 267: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.createCacheServiceServer = exports.CacheServiceMethodList = exports.CacheServiceMethod = exports.CacheServiceClientProtobuf = exports.CacheServiceClientJSON = void 0; +const twirp_ts_1 = __nccwpck_require__(6465); +const cache_1 = __nccwpck_require__(4388); +class CacheServiceClientJSON { + constructor(rpc) { + this.rpc = rpc; + this.CreateCacheEntry.bind(this); + this.FinalizeCacheEntryUpload.bind(this); + this.GetCacheEntryDownloadURL.bind(this); + this.DeleteCacheEntry.bind(this); + this.ListCacheEntries.bind(this); + this.LookupCacheEntry.bind(this); + } + CreateCacheEntry(request) { + const data = cache_1.CreateCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "CreateCacheEntry", "application/json", data); + return promise.then((data) => cache_1.CreateCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + FinalizeCacheEntryUpload(request) { + const data = cache_1.FinalizeCacheEntryUploadRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "FinalizeCacheEntryUpload", "application/json", data); + return promise.then((data) => cache_1.FinalizeCacheEntryUploadResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + GetCacheEntryDownloadURL(request) { + const data = cache_1.GetCacheEntryDownloadURLRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "GetCacheEntryDownloadURL", "application/json", data); + return promise.then((data) => cache_1.GetCacheEntryDownloadURLResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + DeleteCacheEntry(request) { + const data = cache_1.DeleteCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "DeleteCacheEntry", "application/json", data); + return promise.then((data) => cache_1.DeleteCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + ListCacheEntries(request) { + const data = cache_1.ListCacheEntriesRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "ListCacheEntries", "application/json", data); + return promise.then((data) => cache_1.ListCacheEntriesResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } + LookupCacheEntry(request) { + const data = cache_1.LookupCacheEntryRequest.toJson(request, { + useProtoFieldName: true, + emitDefaultValues: false, + }); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "LookupCacheEntry", "application/json", data); + return promise.then((data) => cache_1.LookupCacheEntryResponse.fromJson(data, { + ignoreUnknownFields: true, + })); + } +} +exports.CacheServiceClientJSON = CacheServiceClientJSON; +class CacheServiceClientProtobuf { + constructor(rpc) { + this.rpc = rpc; + this.CreateCacheEntry.bind(this); + this.FinalizeCacheEntryUpload.bind(this); + this.GetCacheEntryDownloadURL.bind(this); + this.DeleteCacheEntry.bind(this); + this.ListCacheEntries.bind(this); + this.LookupCacheEntry.bind(this); + } + CreateCacheEntry(request) { + const data = cache_1.CreateCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "CreateCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.CreateCacheEntryResponse.fromBinary(data)); + } + FinalizeCacheEntryUpload(request) { + const data = cache_1.FinalizeCacheEntryUploadRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "FinalizeCacheEntryUpload", "application/protobuf", data); + return promise.then((data) => cache_1.FinalizeCacheEntryUploadResponse.fromBinary(data)); + } + GetCacheEntryDownloadURL(request) { + const data = cache_1.GetCacheEntryDownloadURLRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "GetCacheEntryDownloadURL", "application/protobuf", data); + return promise.then((data) => cache_1.GetCacheEntryDownloadURLResponse.fromBinary(data)); + } + DeleteCacheEntry(request) { + const data = cache_1.DeleteCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "DeleteCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.DeleteCacheEntryResponse.fromBinary(data)); + } + ListCacheEntries(request) { + const data = cache_1.ListCacheEntriesRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "ListCacheEntries", "application/protobuf", data); + return promise.then((data) => cache_1.ListCacheEntriesResponse.fromBinary(data)); + } + LookupCacheEntry(request) { + const data = cache_1.LookupCacheEntryRequest.toBinary(request); + const promise = this.rpc.request("github.actions.results.api.v1.CacheService", "LookupCacheEntry", "application/protobuf", data); + return promise.then((data) => cache_1.LookupCacheEntryResponse.fromBinary(data)); + } +} +exports.CacheServiceClientProtobuf = CacheServiceClientProtobuf; +var CacheServiceMethod; +(function (CacheServiceMethod) { + CacheServiceMethod["CreateCacheEntry"] = "CreateCacheEntry"; + CacheServiceMethod["FinalizeCacheEntryUpload"] = "FinalizeCacheEntryUpload"; + CacheServiceMethod["GetCacheEntryDownloadURL"] = "GetCacheEntryDownloadURL"; + CacheServiceMethod["DeleteCacheEntry"] = "DeleteCacheEntry"; + CacheServiceMethod["ListCacheEntries"] = "ListCacheEntries"; + CacheServiceMethod["LookupCacheEntry"] = "LookupCacheEntry"; +})(CacheServiceMethod || (exports.CacheServiceMethod = CacheServiceMethod = {})); +exports.CacheServiceMethodList = [ + CacheServiceMethod.CreateCacheEntry, + CacheServiceMethod.FinalizeCacheEntryUpload, + CacheServiceMethod.GetCacheEntryDownloadURL, + CacheServiceMethod.DeleteCacheEntry, + CacheServiceMethod.ListCacheEntries, + CacheServiceMethod.LookupCacheEntry, +]; +function createCacheServiceServer(service) { + return new twirp_ts_1.TwirpServer({ + service, + packageName: "github.actions.results.api.v1", + serviceName: "CacheService", + methodList: exports.CacheServiceMethodList, + matchRoute: matchCacheServiceRoute, + }); +} +exports.createCacheServiceServer = createCacheServiceServer; +function matchCacheServiceRoute(method, events) { + switch (method) { + case "CreateCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "CreateCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceCreateCacheEntryRequest(ctx, service, data, interceptors); + }); + case "FinalizeCacheEntryUpload": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "FinalizeCacheEntryUpload" }); + yield events.onMatch(ctx); + return handleCacheServiceFinalizeCacheEntryUploadRequest(ctx, service, data, interceptors); + }); + case "GetCacheEntryDownloadURL": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "GetCacheEntryDownloadURL" }); + yield events.onMatch(ctx); + return handleCacheServiceGetCacheEntryDownloadURLRequest(ctx, service, data, interceptors); + }); + case "DeleteCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "DeleteCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceDeleteCacheEntryRequest(ctx, service, data, interceptors); + }); + case "ListCacheEntries": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "ListCacheEntries" }); + yield events.onMatch(ctx); + return handleCacheServiceListCacheEntriesRequest(ctx, service, data, interceptors); + }); + case "LookupCacheEntry": + return (ctx, service, data, interceptors) => __awaiter(this, void 0, void 0, function* () { + ctx = Object.assign(Object.assign({}, ctx), { methodName: "LookupCacheEntry" }); + yield events.onMatch(ctx); + return handleCacheServiceLookupCacheEntryRequest(ctx, service, data, interceptors); + }); + default: + events.onNotFound(); + const msg = `no handler found`; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceCreateCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceCreateCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceCreateCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceFinalizeCacheEntryUploadRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceFinalizeCacheEntryUploadJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceFinalizeCacheEntryUploadProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceGetCacheEntryDownloadURLRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceGetCacheEntryDownloadURLJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceGetCacheEntryDownloadURLProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceDeleteCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceDeleteCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceDeleteCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceListCacheEntriesRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceListCacheEntriesJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceListCacheEntriesProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceLookupCacheEntryRequest(ctx, service, data, interceptors) { + switch (ctx.contentType) { + case twirp_ts_1.TwirpContentType.JSON: + return handleCacheServiceLookupCacheEntryJSON(ctx, service, data, interceptors); + case twirp_ts_1.TwirpContentType.Protobuf: + return handleCacheServiceLookupCacheEntryProtobuf(ctx, service, data, interceptors); + default: + const msg = "unexpected Content-Type"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.BadRoute, msg); + } +} +function handleCacheServiceCreateCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.CreateCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.CreateCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.CreateCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.CreateCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceFinalizeCacheEntryUploadJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.FinalizeCacheEntryUploadRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.FinalizeCacheEntryUpload(ctx, inputReq); + }); + } + else { + response = yield service.FinalizeCacheEntryUpload(ctx, request); + } + return JSON.stringify(cache_1.FinalizeCacheEntryUploadResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceGetCacheEntryDownloadURLJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.GetCacheEntryDownloadURLRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.GetCacheEntryDownloadURL(ctx, inputReq); + }); + } + else { + response = yield service.GetCacheEntryDownloadURL(ctx, request); + } + return JSON.stringify(cache_1.GetCacheEntryDownloadURLResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceDeleteCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.DeleteCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.DeleteCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.DeleteCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.DeleteCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceListCacheEntriesJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.ListCacheEntriesRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.ListCacheEntries(ctx, inputReq); + }); + } + else { + response = yield service.ListCacheEntries(ctx, request); + } + return JSON.stringify(cache_1.ListCacheEntriesResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceLookupCacheEntryJSON(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + const body = JSON.parse(data.toString() || "{}"); + request = cache_1.LookupCacheEntryRequest.fromJson(body, { + ignoreUnknownFields: true, + }); + } + catch (e) { + if (e instanceof Error) { + const msg = "the json request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.LookupCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.LookupCacheEntry(ctx, request); + } + return JSON.stringify(cache_1.LookupCacheEntryResponse.toJson(response, { + useProtoFieldName: true, + emitDefaultValues: false, + })); + }); +} +function handleCacheServiceCreateCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.CreateCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.CreateCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.CreateCacheEntry(ctx, request); + } + return Buffer.from(cache_1.CreateCacheEntryResponse.toBinary(response)); + }); +} +function handleCacheServiceFinalizeCacheEntryUploadProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.FinalizeCacheEntryUploadRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.FinalizeCacheEntryUpload(ctx, inputReq); + }); + } + else { + response = yield service.FinalizeCacheEntryUpload(ctx, request); + } + return Buffer.from(cache_1.FinalizeCacheEntryUploadResponse.toBinary(response)); + }); +} +function handleCacheServiceGetCacheEntryDownloadURLProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.GetCacheEntryDownloadURLRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.GetCacheEntryDownloadURL(ctx, inputReq); + }); + } + else { + response = yield service.GetCacheEntryDownloadURL(ctx, request); + } + return Buffer.from(cache_1.GetCacheEntryDownloadURLResponse.toBinary(response)); + }); +} +function handleCacheServiceDeleteCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.DeleteCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.DeleteCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.DeleteCacheEntry(ctx, request); + } + return Buffer.from(cache_1.DeleteCacheEntryResponse.toBinary(response)); + }); +} +function handleCacheServiceListCacheEntriesProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.ListCacheEntriesRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.ListCacheEntries(ctx, inputReq); + }); + } + else { + response = yield service.ListCacheEntries(ctx, request); + } + return Buffer.from(cache_1.ListCacheEntriesResponse.toBinary(response)); + }); +} +function handleCacheServiceLookupCacheEntryProtobuf(ctx, service, data, interceptors) { + return __awaiter(this, void 0, void 0, function* () { + let request; + let response; + try { + request = cache_1.LookupCacheEntryRequest.fromBinary(data); + } + catch (e) { + if (e instanceof Error) { + const msg = "the protobuf request could not be decoded"; + throw new twirp_ts_1.TwirpError(twirp_ts_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + if (interceptors && interceptors.length > 0) { + const interceptor = (0, twirp_ts_1.chainInterceptors)(...interceptors); + response = yield interceptor(ctx, request, (ctx, inputReq) => { + return service.LookupCacheEntry(ctx, inputReq); + }); + } + else { + response = yield service.LookupCacheEntry(ctx, request); + } + return Buffer.from(cache_1.LookupCacheEntryResponse.toBinary(response)); + }); +} +//# sourceMappingURL=cache.twirp.js.map + +/***/ }), + +/***/ 3639: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheEntry = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const timestamp_1 = __nccwpck_require__(4469); +// @generated message type with reflection information, may provide speed optimized methods +class CacheEntry$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheEntry", [ + { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "hash", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 3, name: "size_bytes", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 4, name: "scope", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 5, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 6, name: "created_at", kind: "message", T: () => timestamp_1.Timestamp }, + { no: 7, name: "last_accessed_at", kind: "message", T: () => timestamp_1.Timestamp }, + { no: 8, name: "expires_at", kind: "message", T: () => timestamp_1.Timestamp } + ]); + } + create(value) { + const message = { key: "", hash: "", sizeBytes: "0", scope: "", version: "" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string key */ 1: + message.key = reader.string(); + break; + case /* string hash */ 2: + message.hash = reader.string(); + break; + case /* int64 size_bytes */ 3: + message.sizeBytes = reader.int64().toString(); + break; + case /* string scope */ 4: + message.scope = reader.string(); + break; + case /* string version */ 5: + message.version = reader.string(); + break; + case /* google.protobuf.Timestamp created_at */ 6: + message.createdAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdAt); + break; + case /* google.protobuf.Timestamp last_accessed_at */ 7: + message.lastAccessedAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.lastAccessedAt); + break; + case /* google.protobuf.Timestamp expires_at */ 8: + message.expiresAt = timestamp_1.Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.expiresAt); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* string key = 1; */ + if (message.key !== "") + writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.key); + /* string hash = 2; */ + if (message.hash !== "") + writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.hash); + /* int64 size_bytes = 3; */ + if (message.sizeBytes !== "0") + writer.tag(3, runtime_1.WireType.Varint).int64(message.sizeBytes); + /* string scope = 4; */ + if (message.scope !== "") + writer.tag(4, runtime_1.WireType.LengthDelimited).string(message.scope); + /* string version = 5; */ + if (message.version !== "") + writer.tag(5, runtime_1.WireType.LengthDelimited).string(message.version); + /* google.protobuf.Timestamp created_at = 6; */ + if (message.createdAt) + timestamp_1.Timestamp.internalBinaryWrite(message.createdAt, writer.tag(6, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* google.protobuf.Timestamp last_accessed_at = 7; */ + if (message.lastAccessedAt) + timestamp_1.Timestamp.internalBinaryWrite(message.lastAccessedAt, writer.tag(7, runtime_1.WireType.LengthDelimited).fork(), options).join(); + /* google.protobuf.Timestamp expires_at = 8; */ + if (message.expiresAt) + timestamp_1.Timestamp.internalBinaryWrite(message.expiresAt, writer.tag(8, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheEntry + */ +exports.CacheEntry = new CacheEntry$Type(); +//# sourceMappingURL=cacheentry.js.map + +/***/ }), + +/***/ 7988: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheMetadata = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +const cachescope_1 = __nccwpck_require__(3749); +// @generated message type with reflection information, may provide speed optimized methods +class CacheMetadata$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheMetadata", [ + { no: 1, name: "repository_id", kind: "scalar", T: 3 /*ScalarType.INT64*/ }, + { no: 2, name: "scope", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => cachescope_1.CacheScope } + ]); + } + create(value) { + const message = { repositoryId: "0", scope: [] }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* int64 repository_id */ 1: + message.repositoryId = reader.int64().toString(); + break; + case /* repeated github.actions.results.entities.v1.CacheScope scope */ 2: + message.scope.push(cachescope_1.CacheScope.internalBinaryRead(reader, reader.uint32(), options)); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* int64 repository_id = 1; */ + if (message.repositoryId !== "0") + writer.tag(1, runtime_1.WireType.Varint).int64(message.repositoryId); + /* repeated github.actions.results.entities.v1.CacheScope scope = 2; */ + for (let i = 0; i < message.scope.length; i++) + cachescope_1.CacheScope.internalBinaryWrite(message.scope[i], writer.tag(2, runtime_1.WireType.LengthDelimited).fork(), options).join(); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheMetadata + */ +exports.CacheMetadata = new CacheMetadata$Type(); +//# sourceMappingURL=cachemetadata.js.map + +/***/ }), + +/***/ 3749: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.CacheScope = void 0; +const runtime_1 = __nccwpck_require__(4061); +const runtime_2 = __nccwpck_require__(4061); +const runtime_3 = __nccwpck_require__(4061); +const runtime_4 = __nccwpck_require__(4061); +const runtime_5 = __nccwpck_require__(4061); +// @generated message type with reflection information, may provide speed optimized methods +class CacheScope$Type extends runtime_5.MessageType { + constructor() { + super("github.actions.results.entities.v1.CacheScope", [ + { no: 1, name: "scope", kind: "scalar", T: 9 /*ScalarType.STRING*/ }, + { no: 2, name: "permission", kind: "scalar", T: 3 /*ScalarType.INT64*/ } + ]); + } + create(value) { + const message = { scope: "", permission: "0" }; + globalThis.Object.defineProperty(message, runtime_4.MESSAGE_TYPE, { enumerable: false, value: this }); + if (value !== undefined) + (0, runtime_3.reflectionMergePartial)(this, message, value); + return message; + } + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(), end = reader.pos + length; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case /* string scope */ 1: + message.scope = reader.string(); + break; + case /* int64 permission */ 2: + message.permission = reader.int64().toString(); + break; + default: + let u = options.readUnknownField; + if (u === "throw") + throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d); + } + } + return message; + } + internalBinaryWrite(message, writer, options) { + /* string scope = 1; */ + if (message.scope !== "") + writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.scope); + /* int64 permission = 2; */ + if (message.permission !== "0") + writer.tag(2, runtime_1.WireType.Varint).int64(message.permission); + let u = options.writeUnknownFields; + if (u !== false) + (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer); + return writer; + } +} +/** + * @generated MessageType for protobuf message github.actions.results.entities.v1.CacheScope + */ +exports.CacheScope = new CacheScope$Type(); +//# sourceMappingURL=cachescope.js.map + +/***/ }), + /***/ 8245: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -281,20 +2239,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.saveCache = exports.reserveCache = exports.downloadCache = exports.getCacheEntry = exports.getCacheVersion = void 0; +exports.saveCache = exports.reserveCache = exports.downloadCache = exports.getCacheEntry = void 0; const core = __importStar(__nccwpck_require__(2186)); const http_client_1 = __nccwpck_require__(6255); const auth_1 = __nccwpck_require__(5526); -const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const url_1 = __nccwpck_require__(7310); const utils = __importStar(__nccwpck_require__(1518)); +const uploadUtils_1 = __nccwpck_require__(1786); const downloadUtils_1 = __nccwpck_require__(5500); const options_1 = __nccwpck_require__(6215); const requestUtils_1 = __nccwpck_require__(3981); -const versionSalt = '1.0'; +const config_1 = __nccwpck_require__(5147); +const user_agent_1 = __nccwpck_require__(580); function getCacheApiUrl(resource) { - const baseUrl = process.env['ACTIONS_CACHE_URL'] || ''; + const baseUrl = (0, config_1.getCacheServiceURL)(); if (!baseUrl) { throw new Error('Cache Service Url not found, unable to restore cache.'); } @@ -316,29 +2275,12 @@ function getRequestOptions() { function createHttpClient() { const token = process.env['ACTIONS_RUNTIME_TOKEN'] || ''; const bearerCredentialHandler = new auth_1.BearerCredentialHandler(token); - return new http_client_1.HttpClient('actions/cache', [bearerCredentialHandler], getRequestOptions()); + return new http_client_1.HttpClient((0, user_agent_1.getUserAgentString)(), [bearerCredentialHandler], getRequestOptions()); } -function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) { - // don't pass changes upstream - const components = paths.slice(); - // Add compression method to cache version to restore - // compressed cache as per compression method - if (compressionMethod) { - components.push(compressionMethod); - } - // Only check for windows platforms if enableCrossOsArchive is false - if (process.platform === 'win32' && !enableCrossOsArchive) { - components.push('windows-only'); - } - // Add salt to cache version to support breaking changes in cache entry - components.push(versionSalt); - return crypto.createHash('sha256').update(components.join('|')).digest('hex'); -} -exports.getCacheVersion = getCacheVersion; function getCacheEntry(keys, paths, options) { return __awaiter(this, void 0, void 0, function* () { const httpClient = createHttpClient(); - const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); + const version = utils.getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); const resource = `cache?keys=${encodeURIComponent(keys.join(','))}&version=${version}`; const response = yield (0, requestUtils_1.retryTypedResponse)('getCacheEntry', () => __awaiter(this, void 0, void 0, function* () { return httpClient.getJson(getCacheApiUrl(resource)); })); // Cache not found @@ -409,7 +2351,7 @@ exports.downloadCache = downloadCache; function reserveCache(key, paths, options) { return __awaiter(this, void 0, void 0, function* () { const httpClient = createHttpClient(); - const version = getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); + const version = utils.getCacheVersion(paths, options === null || options === void 0 ? void 0 : options.compressionMethod, options === null || options === void 0 ? void 0 : options.enableCrossOsArchive); const reserveCacheRequest = { key, version, @@ -491,20 +2433,30 @@ function commitCache(httpClient, cacheId, filesize) { })); }); } -function saveCache(cacheId, archivePath, options) { +function saveCache(cacheId, archivePath, signedUploadURL, options) { return __awaiter(this, void 0, void 0, function* () { - const httpClient = createHttpClient(); - core.debug('Upload cache'); - yield uploadFile(httpClient, cacheId, archivePath, options); - // Commit Cache - core.debug('Commiting cache'); - const cacheSize = utils.getArchiveFileSizeInBytes(archivePath); - core.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`); - const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize); - if (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode)) { - throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`); + const uploadOptions = (0, options_1.getUploadOptions)(options); + if (uploadOptions.useAzureSdk) { + // Use Azure storage SDK to upload caches directly to Azure + if (!signedUploadURL) { + throw new Error('Azure Storage SDK can only be used when a signed URL is provided.'); + } + yield (0, uploadUtils_1.uploadCacheArchiveSDK)(signedUploadURL, archivePath, options); + } + else { + const httpClient = createHttpClient(); + core.debug('Upload cache'); + yield uploadFile(httpClient, cacheId, archivePath, options); + // Commit Cache + core.debug('Commiting cache'); + const cacheSize = utils.getArchiveFileSizeInBytes(archivePath); + core.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`); + const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize); + if (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode)) { + throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`); + } + core.info('Cache saved successfully'); } - core.info('Cache saved successfully'); }); } exports.saveCache = saveCache; @@ -557,17 +2509,18 @@ var __asyncValues = (this && this.__asyncValues) || function (o) { function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); } }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.isGhes = exports.assertDefined = exports.getGnuTarPathOnWindows = exports.getCacheFileName = exports.getCompressionMethod = exports.unlinkFile = exports.resolvePaths = exports.getArchiveFileSizeInBytes = exports.createTempDirectory = void 0; +exports.getRuntimeToken = exports.getCacheVersion = exports.assertDefined = exports.getGnuTarPathOnWindows = exports.getCacheFileName = exports.getCompressionMethod = exports.unlinkFile = exports.resolvePaths = exports.getArchiveFileSizeInBytes = exports.createTempDirectory = void 0; const core = __importStar(__nccwpck_require__(2186)); const exec = __importStar(__nccwpck_require__(1514)); const glob = __importStar(__nccwpck_require__(1597)); const io = __importStar(__nccwpck_require__(7436)); +const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const path = __importStar(__nccwpck_require__(1017)); const semver = __importStar(__nccwpck_require__(3771)); const util = __importStar(__nccwpck_require__(3837)); -const uuid_1 = __nccwpck_require__(2155); const constants_1 = __nccwpck_require__(8840); +const versionSalt = '1.0'; // From https://github.com/actions/toolkit/blob/main/packages/tool-cache/src/tool-cache.ts#L23 function createTempDirectory() { return __awaiter(this, void 0, void 0, function* () { @@ -589,7 +2542,7 @@ function createTempDirectory() { } tempDirectory = path.join(baseLocation, 'actions', 'temp'); } - const dest = path.join(tempDirectory, (0, uuid_1.v4)()); + const dest = path.join(tempDirectory, crypto.randomUUID()); yield io.mkdirP(dest); return dest; }); @@ -705,15 +2658,76 @@ function assertDefined(name, value) { return value; } exports.assertDefined = assertDefined; +function getCacheVersion(paths, compressionMethod, enableCrossOsArchive = false) { + // don't pass changes upstream + const components = paths.slice(); + // Add compression method to cache version to restore + // compressed cache as per compression method + if (compressionMethod) { + components.push(compressionMethod); + } + // Only check for windows platforms if enableCrossOsArchive is false + if (process.platform === 'win32' && !enableCrossOsArchive) { + components.push('windows-only'); + } + // Add salt to cache version to support breaking changes in cache entry + components.push(versionSalt); + return crypto.createHash('sha256').update(components.join('|')).digest('hex'); +} +exports.getCacheVersion = getCacheVersion; +function getRuntimeToken() { + const token = process.env['ACTIONS_RUNTIME_TOKEN']; + if (!token) { + throw new Error('Unable to get the ACTIONS_RUNTIME_TOKEN env variable'); + } + return token; +} +exports.getRuntimeToken = getRuntimeToken; +//# sourceMappingURL=cacheUtils.js.map + +/***/ }), + +/***/ 5147: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getCacheServiceURL = exports.getCacheServiceVersion = exports.isGhes = void 0; function isGhes() { const ghUrl = new URL(process.env['GITHUB_SERVER_URL'] || 'https://github.com'); const hostname = ghUrl.hostname.trimEnd().toUpperCase(); const isGitHubHost = hostname === 'GITHUB.COM'; - const isGheHost = hostname.endsWith('.GHE.COM') || hostname.endsWith('.GHE.LOCALHOST'); - return !isGitHubHost && !isGheHost; + const isGheHost = hostname.endsWith('.GHE.COM'); + const isLocalHost = hostname.endsWith('.LOCALHOST'); + return !isGitHubHost && !isGheHost && !isLocalHost; } exports.isGhes = isGhes; -//# sourceMappingURL=cacheUtils.js.map +function getCacheServiceVersion() { + // Cache service v2 is not supported on GHES. We will default to + // cache service v1 even if the feature flag was enabled by user. + if (isGhes()) + return 'v1'; + return process.env['ACTIONS_CACHE_SERVICE_V2'] ? 'v2' : 'v1'; +} +exports.getCacheServiceVersion = getCacheServiceVersion; +function getCacheServiceURL() { + const version = getCacheServiceVersion(); + // Based on the version of the cache service, we will determine which + // URL to use. + switch (version) { + case 'v1': + return (process.env['ACTIONS_CACHE_URL'] || + process.env['ACTIONS_RESULTS_URL'] || + ''); + case 'v2': + return process.env['ACTIONS_RESULTS_URL'] || ''; + default: + throw new Error(`Unsupported cache service version: ${version}`); + } +} +exports.getCacheServiceURL = getCacheServiceURL; +//# sourceMappingURL=config.js.map /***/ }), @@ -723,7 +2737,7 @@ exports.isGhes = isGhes; "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.ManifestFilename = exports.TarFilename = exports.SystemTarPathOnWindows = exports.GnuTarPathOnWindows = exports.SocketTimeout = exports.DefaultRetryDelay = exports.DefaultRetryAttempts = exports.ArchiveToolType = exports.CompressionMethod = exports.CacheFilename = void 0; +exports.CacheFileSizeLimit = exports.ManifestFilename = exports.TarFilename = exports.SystemTarPathOnWindows = exports.GnuTarPathOnWindows = exports.SocketTimeout = exports.DefaultRetryDelay = exports.DefaultRetryAttempts = exports.ArchiveToolType = exports.CompressionMethod = exports.CacheFilename = void 0; var CacheFilename; (function (CacheFilename) { CacheFilename["Gzip"] = "cache.tgz"; @@ -756,6 +2770,7 @@ exports.GnuTarPathOnWindows = `${process.env['PROGRAMFILES']}\\Git\\usr\\bin\\ta exports.SystemTarPathOnWindows = `${process.env['SYSTEMDRIVE']}\\Windows\\System32\\tar.exe`; exports.TarFilename = 'cache.tar'; exports.ManifestFilename = 'manifest.txt'; +exports.CacheFileSizeLimit = 10 * Math.pow(1024, 3); // 10GiB per repository //# sourceMappingURL=constants.js.map /***/ }), @@ -1289,6 +3304,270 @@ exports.retryHttpClientResponse = retryHttpClientResponse; /***/ }), +/***/ 2502: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.internalCacheTwirpClient = void 0; +const core_1 = __nccwpck_require__(2186); +const user_agent_1 = __nccwpck_require__(580); +const errors_1 = __nccwpck_require__(8223); +const config_1 = __nccwpck_require__(5147); +const cacheUtils_1 = __nccwpck_require__(1518); +const auth_1 = __nccwpck_require__(5526); +const http_client_1 = __nccwpck_require__(6255); +const cache_twirp_1 = __nccwpck_require__(267); +/** + * This class is a wrapper around the CacheServiceClientJSON class generated by Twirp. + * + * It adds retry logic to the request method, which is not present in the generated client. + * + * This class is used to interact with cache service v2. + */ +class CacheServiceClient { + constructor(userAgent, maxAttempts, baseRetryIntervalMilliseconds, retryMultiplier) { + this.maxAttempts = 5; + this.baseRetryIntervalMilliseconds = 3000; + this.retryMultiplier = 1.5; + const token = (0, cacheUtils_1.getRuntimeToken)(); + this.baseUrl = (0, config_1.getCacheServiceURL)(); + if (maxAttempts) { + this.maxAttempts = maxAttempts; + } + if (baseRetryIntervalMilliseconds) { + this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds; + } + if (retryMultiplier) { + this.retryMultiplier = retryMultiplier; + } + this.httpClient = new http_client_1.HttpClient(userAgent, [ + new auth_1.BearerCredentialHandler(token) + ]); + } + // This function satisfies the Rpc interface. It is compatible with the JSON + // JSON generated client. + request(service, method, contentType, data) { + return __awaiter(this, void 0, void 0, function* () { + const url = new URL(`/twirp/${service}/${method}`, this.baseUrl).href; + (0, core_1.debug)(`[Request] ${method} ${url}`); + const headers = { + 'Content-Type': contentType + }; + try { + const { body } = yield this.retryableRequest(() => __awaiter(this, void 0, void 0, function* () { return this.httpClient.post(url, JSON.stringify(data), headers); })); + return body; + } + catch (error) { + throw new Error(`Failed to ${method}: ${error.message}`); + } + }); + } + retryableRequest(operation) { + return __awaiter(this, void 0, void 0, function* () { + let attempt = 0; + let errorMessage = ''; + let rawBody = ''; + while (attempt < this.maxAttempts) { + let isRetryable = false; + try { + const response = yield operation(); + const statusCode = response.message.statusCode; + rawBody = yield response.readBody(); + (0, core_1.debug)(`[Response] - ${response.message.statusCode}`); + (0, core_1.debug)(`Headers: ${JSON.stringify(response.message.headers, null, 2)}`); + const body = JSON.parse(rawBody); + (0, core_1.debug)(`Body: ${JSON.stringify(body, null, 2)}`); + if (this.isSuccessStatusCode(statusCode)) { + return { response, body }; + } + isRetryable = this.isRetryableHttpStatusCode(statusCode); + errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`; + if (body.msg) { + if (errors_1.UsageError.isUsageErrorMessage(body.msg)) { + throw new errors_1.UsageError(); + } + errorMessage = `${errorMessage}: ${body.msg}`; + } + } + catch (error) { + if (error instanceof SyntaxError) { + (0, core_1.debug)(`Raw Body: ${rawBody}`); + } + if (error instanceof errors_1.UsageError) { + throw error; + } + if (errors_1.NetworkError.isNetworkErrorCode(error === null || error === void 0 ? void 0 : error.code)) { + throw new errors_1.NetworkError(error === null || error === void 0 ? void 0 : error.code); + } + isRetryable = true; + errorMessage = error.message; + } + if (!isRetryable) { + throw new Error(`Received non-retryable error: ${errorMessage}`); + } + if (attempt + 1 === this.maxAttempts) { + throw new Error(`Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`); + } + const retryTimeMilliseconds = this.getExponentialRetryTimeMilliseconds(attempt); + (0, core_1.info)(`Attempt ${attempt + 1} of ${this.maxAttempts} failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`); + yield this.sleep(retryTimeMilliseconds); + attempt++; + } + throw new Error(`Request failed`); + }); + } + isSuccessStatusCode(statusCode) { + if (!statusCode) + return false; + return statusCode >= 200 && statusCode < 300; + } + isRetryableHttpStatusCode(statusCode) { + if (!statusCode) + return false; + const retryableStatusCodes = [ + http_client_1.HttpCodes.BadGateway, + http_client_1.HttpCodes.GatewayTimeout, + http_client_1.HttpCodes.InternalServerError, + http_client_1.HttpCodes.ServiceUnavailable, + http_client_1.HttpCodes.TooManyRequests + ]; + return retryableStatusCodes.includes(statusCode); + } + sleep(milliseconds) { + return __awaiter(this, void 0, void 0, function* () { + return new Promise(resolve => setTimeout(resolve, milliseconds)); + }); + } + getExponentialRetryTimeMilliseconds(attempt) { + if (attempt < 0) { + throw new Error('attempt should be a positive integer'); + } + if (attempt === 0) { + return this.baseRetryIntervalMilliseconds; + } + const minTime = this.baseRetryIntervalMilliseconds * Math.pow(this.retryMultiplier, attempt); + const maxTime = minTime * this.retryMultiplier; + // returns a random number between minTime and maxTime (exclusive) + return Math.trunc(Math.random() * (maxTime - minTime) + minTime); + } +} +function internalCacheTwirpClient(options) { + const client = new CacheServiceClient((0, user_agent_1.getUserAgentString)(), options === null || options === void 0 ? void 0 : options.maxAttempts, options === null || options === void 0 ? void 0 : options.retryIntervalMs, options === null || options === void 0 ? void 0 : options.retryMultiplier); + return new cache_twirp_1.CacheServiceClientJSON(client); +} +exports.internalCacheTwirpClient = internalCacheTwirpClient; +//# sourceMappingURL=cacheTwirpClient.js.map + +/***/ }), + +/***/ 8223: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.UsageError = exports.NetworkError = exports.GHESNotSupportedError = exports.CacheNotFoundError = exports.InvalidResponseError = exports.FilesNotFoundError = void 0; +class FilesNotFoundError extends Error { + constructor(files = []) { + let message = 'No files were found to upload'; + if (files.length > 0) { + message += `: ${files.join(', ')}`; + } + super(message); + this.files = files; + this.name = 'FilesNotFoundError'; + } +} +exports.FilesNotFoundError = FilesNotFoundError; +class InvalidResponseError extends Error { + constructor(message) { + super(message); + this.name = 'InvalidResponseError'; + } +} +exports.InvalidResponseError = InvalidResponseError; +class CacheNotFoundError extends Error { + constructor(message = 'Cache not found') { + super(message); + this.name = 'CacheNotFoundError'; + } +} +exports.CacheNotFoundError = CacheNotFoundError; +class GHESNotSupportedError extends Error { + constructor(message = '@actions/cache v4.1.4+, actions/cache/save@v4+ and actions/cache/restore@v4+ are not currently supported on GHES.') { + super(message); + this.name = 'GHESNotSupportedError'; + } +} +exports.GHESNotSupportedError = GHESNotSupportedError; +class NetworkError extends Error { + constructor(code) { + const message = `Unable to make request: ${code}\nIf you are using self-hosted runners, please make sure your runner has access to all GitHub endpoints: https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/about-self-hosted-runners#communication-between-self-hosted-runners-and-github`; + super(message); + this.code = code; + this.name = 'NetworkError'; + } +} +exports.NetworkError = NetworkError; +NetworkError.isNetworkErrorCode = (code) => { + if (!code) + return false; + return [ + 'ECONNRESET', + 'ENOTFOUND', + 'ETIMEDOUT', + 'ECONNREFUSED', + 'EHOSTUNREACH' + ].includes(code); +}; +class UsageError extends Error { + constructor() { + const message = `Cache storage quota has been hit. Unable to upload any new cache entries. Usage is recalculated every 6-12 hours.\nMore info on storage limits: https://docs.github.com/en/billing/managing-billing-for-github-actions/about-billing-for-github-actions#calculating-minute-and-storage-spending`; + super(message); + this.name = 'UsageError'; + } +} +exports.UsageError = UsageError; +UsageError.isUsageErrorMessage = (msg) => { + if (!msg) + return false; + return msg.includes('insufficient usage'); +}; +//# sourceMappingURL=errors.js.map + +/***/ }), + +/***/ 580: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getUserAgentString = void 0; +// eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports +const packageJson = __nccwpck_require__(9167); +/** + * Ensure that this User Agent String is used in all HTTP calls so that we can monitor telemetry between different versions of this package + */ +function getUserAgentString() { + return `@actions/cache-${packageJson.version}`; +} +exports.getUserAgentString = getUserAgentString; +//# sourceMappingURL=user-agent.js.map + +/***/ }), + /***/ 6490: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -1568,6 +3847,180 @@ exports.createTar = createTar; /***/ }), +/***/ 1786: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.uploadCacheArchiveSDK = exports.UploadProgress = void 0; +const core = __importStar(__nccwpck_require__(2186)); +const storage_blob_1 = __nccwpck_require__(4100); +const errors_1 = __nccwpck_require__(8223); +/** + * Class for tracking the upload state and displaying stats. + */ +class UploadProgress { + constructor(contentLength) { + this.contentLength = contentLength; + this.sentBytes = 0; + this.displayedComplete = false; + this.startTime = Date.now(); + } + /** + * Sets the number of bytes sent + * + * @param sentBytes the number of bytes sent + */ + setSentBytes(sentBytes) { + this.sentBytes = sentBytes; + } + /** + * Returns the total number of bytes transferred. + */ + getTransferredBytes() { + return this.sentBytes; + } + /** + * Returns true if the upload is complete. + */ + isDone() { + return this.getTransferredBytes() === this.contentLength; + } + /** + * Prints the current upload stats. Once the upload completes, this will print one + * last line and then stop. + */ + display() { + if (this.displayedComplete) { + return; + } + const transferredBytes = this.sentBytes; + const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1); + const elapsedTime = Date.now() - this.startTime; + const uploadSpeed = (transferredBytes / + (1024 * 1024) / + (elapsedTime / 1000)).toFixed(1); + core.info(`Sent ${transferredBytes} of ${this.contentLength} (${percentage}%), ${uploadSpeed} MBs/sec`); + if (this.isDone()) { + this.displayedComplete = true; + } + } + /** + * Returns a function used to handle TransferProgressEvents. + */ + onProgress() { + return (progress) => { + this.setSentBytes(progress.loadedBytes); + }; + } + /** + * Starts the timer that displays the stats. + * + * @param delayInMs the delay between each write + */ + startDisplayTimer(delayInMs = 1000) { + const displayCallback = () => { + this.display(); + if (!this.isDone()) { + this.timeoutHandle = setTimeout(displayCallback, delayInMs); + } + }; + this.timeoutHandle = setTimeout(displayCallback, delayInMs); + } + /** + * Stops the timer that displays the stats. As this typically indicates the upload + * is complete, this will display one last line, unless the last line has already + * been written. + */ + stopDisplayTimer() { + if (this.timeoutHandle) { + clearTimeout(this.timeoutHandle); + this.timeoutHandle = undefined; + } + this.display(); + } +} +exports.UploadProgress = UploadProgress; +/** + * Uploads a cache archive directly to Azure Blob Storage using the Azure SDK. + * This function will display progress information to the console. Concurrency of the + * upload is determined by the calling functions. + * + * @param signedUploadURL + * @param archivePath + * @param options + * @returns + */ +function uploadCacheArchiveSDK(signedUploadURL, archivePath, options) { + var _a; + return __awaiter(this, void 0, void 0, function* () { + const blobClient = new storage_blob_1.BlobClient(signedUploadURL); + const blockBlobClient = blobClient.getBlockBlobClient(); + const uploadProgress = new UploadProgress((_a = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a !== void 0 ? _a : 0); + // Specify data transfer options + const uploadOptions = { + blockSize: options === null || options === void 0 ? void 0 : options.uploadChunkSize, + concurrency: options === null || options === void 0 ? void 0 : options.uploadConcurrency, + maxSingleShotSize: 128 * 1024 * 1024, + onProgress: uploadProgress.onProgress() + }; + try { + uploadProgress.startDisplayTimer(); + core.debug(`BlobClient: ${blobClient.name}:${blobClient.accountName}:${blobClient.containerName}`); + const response = yield blockBlobClient.uploadFile(archivePath, uploadOptions); + // TODO: better management of non-retryable errors + if (response._response.status >= 400) { + throw new errors_1.InvalidResponseError(`uploadCacheArchiveSDK: upload failed with status code ${response._response.status}`); + } + return response; + } + catch (error) { + core.warning(`uploadCacheArchiveSDK: internal error uploading cache archive: ${error.message}`); + throw error; + } + finally { + uploadProgress.stopDisplayTimer(); + } + }); +} +exports.uploadCacheArchiveSDK = uploadCacheArchiveSDK; +//# sourceMappingURL=uploadUtils.js.map + +/***/ }), + /***/ 6215: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -1605,11 +4058,16 @@ const core = __importStar(__nccwpck_require__(2186)); * @param copy the original upload options */ function getUploadOptions(copy) { + // Defaults if not overriden const result = { + useAzureSdk: false, uploadConcurrency: 4, uploadChunkSize: 32 * 1024 * 1024 }; if (copy) { + if (typeof copy.useAzureSdk === 'boolean') { + result.useAzureSdk = copy.useAzureSdk; + } if (typeof copy.uploadConcurrency === 'number') { result.uploadConcurrency = copy.uploadConcurrency; } @@ -1617,6 +4075,18 @@ function getUploadOptions(copy) { result.uploadChunkSize = copy.uploadChunkSize; } } + /** + * Add env var overrides + */ + // Cap the uploadConcurrency at 32 + result.uploadConcurrency = !isNaN(Number(process.env['CACHE_UPLOAD_CONCURRENCY'])) + ? Math.min(32, Number(process.env['CACHE_UPLOAD_CONCURRENCY'])) + : result.uploadConcurrency; + // Cap the uploadChunkSize at 128MiB + result.uploadChunkSize = !isNaN(Number(process.env['CACHE_UPLOAD_CHUNK_SIZE'])) + ? Math.min(128 * 1024 * 1024, Number(process.env['CACHE_UPLOAD_CHUNK_SIZE']) * 1024 * 1024) + : result.uploadChunkSize; + core.debug(`Use Azure SDK: ${result.useAzureSdk}`); core.debug(`Upload concurrency: ${result.uploadConcurrency}`); core.debug(`Upload chunk size: ${result.uploadChunkSize}`); return result; @@ -4395,7 +6865,11 @@ function coerce (version, options) { var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4408,7 +6882,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4470,13 +6944,13 @@ class Command { } } function escapeData(s) { - return utils_1.toCommandValue(s) + return (0, utils_1.toCommandValue)(s) .replace(/%/g, '%25') .replace(/\r/g, '%0D') .replace(/\n/g, '%0A'); } function escapeProperty(s) { - return utils_1.toCommandValue(s) + return (0, utils_1.toCommandValue)(s) .replace(/%/g, '%25') .replace(/\r/g, '%0D') .replace(/\n/g, '%0A') @@ -4494,7 +6968,11 @@ function escapeProperty(s) { var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4507,7 +6985,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4521,7 +6999,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge }); }; Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; +exports.platform = exports.toPlatformPath = exports.toWin32Path = exports.toPosixPath = exports.markdownSummary = exports.summary = exports.getIDToken = exports.getState = exports.saveState = exports.group = exports.endGroup = exports.startGroup = exports.info = exports.notice = exports.warning = exports.error = exports.debug = exports.isDebug = exports.setFailed = exports.setCommandEcho = exports.setOutput = exports.getBooleanInput = exports.getMultilineInput = exports.getInput = exports.addPath = exports.setSecret = exports.exportVariable = exports.ExitCode = void 0; const command_1 = __nccwpck_require__(7351); const file_command_1 = __nccwpck_require__(717); const utils_1 = __nccwpck_require__(5278); @@ -4541,7 +7019,7 @@ var ExitCode; * A code indicating that the action was a failure */ ExitCode[ExitCode["Failure"] = 1] = "Failure"; -})(ExitCode = exports.ExitCode || (exports.ExitCode = {})); +})(ExitCode || (exports.ExitCode = ExitCode = {})); //----------------------------------------------------------------------- // Variables //----------------------------------------------------------------------- @@ -4552,13 +7030,13 @@ var ExitCode; */ // eslint-disable-next-line @typescript-eslint/no-explicit-any function exportVariable(name, val) { - const convertedVal = utils_1.toCommandValue(val); + const convertedVal = (0, utils_1.toCommandValue)(val); process.env[name] = convertedVal; const filePath = process.env['GITHUB_ENV'] || ''; if (filePath) { - return file_command_1.issueFileCommand('ENV', file_command_1.prepareKeyValueMessage(name, val)); + return (0, file_command_1.issueFileCommand)('ENV', (0, file_command_1.prepareKeyValueMessage)(name, val)); } - command_1.issueCommand('set-env', { name }, convertedVal); + (0, command_1.issueCommand)('set-env', { name }, convertedVal); } exports.exportVariable = exportVariable; /** @@ -4566,7 +7044,7 @@ exports.exportVariable = exportVariable; * @param secret value of the secret */ function setSecret(secret) { - command_1.issueCommand('add-mask', {}, secret); + (0, command_1.issueCommand)('add-mask', {}, secret); } exports.setSecret = setSecret; /** @@ -4576,10 +7054,10 @@ exports.setSecret = setSecret; function addPath(inputPath) { const filePath = process.env['GITHUB_PATH'] || ''; if (filePath) { - file_command_1.issueFileCommand('PATH', inputPath); + (0, file_command_1.issueFileCommand)('PATH', inputPath); } else { - command_1.issueCommand('add-path', {}, inputPath); + (0, command_1.issueCommand)('add-path', {}, inputPath); } process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`; } @@ -4654,10 +7132,10 @@ exports.getBooleanInput = getBooleanInput; function setOutput(name, value) { const filePath = process.env['GITHUB_OUTPUT'] || ''; if (filePath) { - return file_command_1.issueFileCommand('OUTPUT', file_command_1.prepareKeyValueMessage(name, value)); + return (0, file_command_1.issueFileCommand)('OUTPUT', (0, file_command_1.prepareKeyValueMessage)(name, value)); } process.stdout.write(os.EOL); - command_1.issueCommand('set-output', { name }, utils_1.toCommandValue(value)); + (0, command_1.issueCommand)('set-output', { name }, (0, utils_1.toCommandValue)(value)); } exports.setOutput = setOutput; /** @@ -4666,7 +7144,7 @@ exports.setOutput = setOutput; * */ function setCommandEcho(enabled) { - command_1.issue('echo', enabled ? 'on' : 'off'); + (0, command_1.issue)('echo', enabled ? 'on' : 'off'); } exports.setCommandEcho = setCommandEcho; //----------------------------------------------------------------------- @@ -4697,7 +7175,7 @@ exports.isDebug = isDebug; * @param message debug message */ function debug(message) { - command_1.issueCommand('debug', {}, message); + (0, command_1.issueCommand)('debug', {}, message); } exports.debug = debug; /** @@ -4706,7 +7184,7 @@ exports.debug = debug; * @param properties optional properties to add to the annotation. */ function error(message, properties = {}) { - command_1.issueCommand('error', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('error', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.error = error; /** @@ -4715,7 +7193,7 @@ exports.error = error; * @param properties optional properties to add to the annotation. */ function warning(message, properties = {}) { - command_1.issueCommand('warning', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('warning', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.warning = warning; /** @@ -4724,7 +7202,7 @@ exports.warning = warning; * @param properties optional properties to add to the annotation. */ function notice(message, properties = {}) { - command_1.issueCommand('notice', utils_1.toCommandProperties(properties), message instanceof Error ? message.toString() : message); + (0, command_1.issueCommand)('notice', (0, utils_1.toCommandProperties)(properties), message instanceof Error ? message.toString() : message); } exports.notice = notice; /** @@ -4743,14 +7221,14 @@ exports.info = info; * @param name The name of the output group */ function startGroup(name) { - command_1.issue('group', name); + (0, command_1.issue)('group', name); } exports.startGroup = startGroup; /** * End an output group. */ function endGroup() { - command_1.issue('endgroup'); + (0, command_1.issue)('endgroup'); } exports.endGroup = endGroup; /** @@ -4788,9 +7266,9 @@ exports.group = group; function saveState(name, value) { const filePath = process.env['GITHUB_STATE'] || ''; if (filePath) { - return file_command_1.issueFileCommand('STATE', file_command_1.prepareKeyValueMessage(name, value)); + return (0, file_command_1.issueFileCommand)('STATE', (0, file_command_1.prepareKeyValueMessage)(name, value)); } - command_1.issueCommand('save-state', { name }, utils_1.toCommandValue(value)); + (0, command_1.issueCommand)('save-state', { name }, (0, utils_1.toCommandValue)(value)); } exports.saveState = saveState; /** @@ -4826,6 +7304,10 @@ var path_utils_1 = __nccwpck_require__(2981); Object.defineProperty(exports, "toPosixPath", ({ enumerable: true, get: function () { return path_utils_1.toPosixPath; } })); Object.defineProperty(exports, "toWin32Path", ({ enumerable: true, get: function () { return path_utils_1.toWin32Path; } })); Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: function () { return path_utils_1.toPlatformPath; } })); +/** + * Platform utilities exports + */ +exports.platform = __importStar(__nccwpck_require__(5243)); //# sourceMappingURL=core.js.map /***/ }), @@ -4838,7 +7320,11 @@ Object.defineProperty(exports, "toPlatformPath", ({ enumerable: true, get: funct // For internal use, subject to change. var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4851,7 +7337,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -4859,9 +7345,9 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); exports.prepareKeyValueMessage = exports.issueFileCommand = void 0; // We use any as a valid input type /* eslint-disable @typescript-eslint/no-explicit-any */ +const crypto = __importStar(__nccwpck_require__(6113)); const fs = __importStar(__nccwpck_require__(7147)); const os = __importStar(__nccwpck_require__(2037)); -const uuid_1 = __nccwpck_require__(8974); const utils_1 = __nccwpck_require__(5278); function issueFileCommand(command, message) { const filePath = process.env[`GITHUB_${command}`]; @@ -4871,14 +7357,14 @@ function issueFileCommand(command, message) { if (!fs.existsSync(filePath)) { throw new Error(`Missing file at path: ${filePath}`); } - fs.appendFileSync(filePath, `${utils_1.toCommandValue(message)}${os.EOL}`, { + fs.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os.EOL}`, { encoding: 'utf8' }); } exports.issueFileCommand = issueFileCommand; function prepareKeyValueMessage(key, value) { - const delimiter = `ghadelimiter_${uuid_1.v4()}`; - const convertedValue = utils_1.toCommandValue(value); + const delimiter = `ghadelimiter_${crypto.randomUUID()}`; + const convertedValue = (0, utils_1.toCommandValue)(value); // These should realistically never happen, but just in case someone finds a // way to exploit uuid generation let's not allow keys or values that contain // the delimiter. @@ -4963,9 +7449,9 @@ class OidcClient { const encodedAudience = encodeURIComponent(audience); id_token_url = `${id_token_url}&audience=${encodedAudience}`; } - core_1.debug(`ID token url is ${id_token_url}`); + (0, core_1.debug)(`ID token url is ${id_token_url}`); const id_token = yield OidcClient.getCall(id_token_url); - core_1.setSecret(id_token); + (0, core_1.setSecret)(id_token); return id_token; } catch (error) { @@ -4986,7 +7472,11 @@ exports.OidcClient = OidcClient; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; - Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; @@ -4999,7 +7489,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? ( var __importStar = (this && this.__importStar) || function (mod) { if (mod && mod.__esModule) return mod; var result = {}; - if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); __setModuleDefault(result, mod); return result; }; @@ -5044,6 +7534,107 @@ exports.toPlatformPath = toPlatformPath; /***/ }), +/***/ 5243: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getDetails = exports.isLinux = exports.isMacOS = exports.isWindows = exports.arch = exports.platform = void 0; +const os_1 = __importDefault(__nccwpck_require__(2037)); +const exec = __importStar(__nccwpck_require__(1514)); +const getWindowsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout: version } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Version"', undefined, { + silent: true + }); + const { stdout: name } = yield exec.getExecOutput('powershell -command "(Get-CimInstance -ClassName Win32_OperatingSystem).Caption"', undefined, { + silent: true + }); + return { + name: name.trim(), + version: version.trim() + }; +}); +const getMacOsInfo = () => __awaiter(void 0, void 0, void 0, function* () { + var _a, _b, _c, _d; + const { stdout } = yield exec.getExecOutput('sw_vers', undefined, { + silent: true + }); + const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : ''; + const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ''; + return { + name, + version + }; +}); +const getLinuxInfo = () => __awaiter(void 0, void 0, void 0, function* () { + const { stdout } = yield exec.getExecOutput('lsb_release', ['-i', '-r', '-s'], { + silent: true + }); + const [name, version] = stdout.trim().split('\n'); + return { + name, + version + }; +}); +exports.platform = os_1.default.platform(); +exports.arch = os_1.default.arch(); +exports.isWindows = exports.platform === 'win32'; +exports.isMacOS = exports.platform === 'darwin'; +exports.isLinux = exports.platform === 'linux'; +function getDetails() { + return __awaiter(this, void 0, void 0, function* () { + return Object.assign(Object.assign({}, (yield (exports.isWindows + ? getWindowsInfo() + : exports.isMacOS + ? getMacOsInfo() + : getLinuxInfo()))), { platform: exports.platform, + arch: exports.arch, + isWindows: exports.isWindows, + isMacOS: exports.isMacOS, + isLinux: exports.isLinux }); + }); +} +exports.getDetails = getDetails; +//# sourceMappingURL=platform.js.map + +/***/ }), + /***/ 1327: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -5381,652 +7972,6 @@ exports.toCommandProperties = toCommandProperties; /***/ }), -/***/ 8974: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -Object.defineProperty(exports, "v1", ({ - enumerable: true, - get: function () { - return _v.default; - } -})); -Object.defineProperty(exports, "v3", ({ - enumerable: true, - get: function () { - return _v2.default; - } -})); -Object.defineProperty(exports, "v4", ({ - enumerable: true, - get: function () { - return _v3.default; - } -})); -Object.defineProperty(exports, "v5", ({ - enumerable: true, - get: function () { - return _v4.default; - } -})); -Object.defineProperty(exports, "NIL", ({ - enumerable: true, - get: function () { - return _nil.default; - } -})); -Object.defineProperty(exports, "version", ({ - enumerable: true, - get: function () { - return _version.default; - } -})); -Object.defineProperty(exports, "validate", ({ - enumerable: true, - get: function () { - return _validate.default; - } -})); -Object.defineProperty(exports, "stringify", ({ - enumerable: true, - get: function () { - return _stringify.default; - } -})); -Object.defineProperty(exports, "parse", ({ - enumerable: true, - get: function () { - return _parse.default; - } -})); - -var _v = _interopRequireDefault(__nccwpck_require__(1595)); - -var _v2 = _interopRequireDefault(__nccwpck_require__(6993)); - -var _v3 = _interopRequireDefault(__nccwpck_require__(1472)); - -var _v4 = _interopRequireDefault(__nccwpck_require__(6217)); - -var _nil = _interopRequireDefault(__nccwpck_require__(2381)); - -var _version = _interopRequireDefault(__nccwpck_require__(427)); - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -var _parse = _interopRequireDefault(__nccwpck_require__(6385)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/***/ }), - -/***/ 5842: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function md5(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('md5').update(bytes).digest(); -} - -var _default = md5; -exports["default"] = _default; - -/***/ }), - -/***/ 2381: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = '00000000-0000-0000-0000-000000000000'; -exports["default"] = _default; - -/***/ }), - -/***/ 6385: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function parse(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - let v; - const arr = new Uint8Array(16); // Parse ########-....-....-....-............ - - arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; - arr[1] = v >>> 16 & 0xff; - arr[2] = v >>> 8 & 0xff; - arr[3] = v & 0xff; // Parse ........-####-....-....-............ - - arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; - arr[5] = v & 0xff; // Parse ........-....-####-....-............ - - arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; - arr[7] = v & 0xff; // Parse ........-....-....-####-............ - - arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; - arr[9] = v & 0xff; // Parse ........-....-....-....-############ - // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) - - arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; - arr[11] = v / 0x100000000 & 0xff; - arr[12] = v >>> 24 & 0xff; - arr[13] = v >>> 16 & 0xff; - arr[14] = v >>> 8 & 0xff; - arr[15] = v & 0xff; - return arr; -} - -var _default = parse; -exports["default"] = _default; - -/***/ }), - -/***/ 6230: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; -exports["default"] = _default; - -/***/ }), - -/***/ 9784: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = rng; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate - -let poolPtr = rnds8Pool.length; - -function rng() { - if (poolPtr > rnds8Pool.length - 16) { - _crypto.default.randomFillSync(rnds8Pool); - - poolPtr = 0; - } - - return rnds8Pool.slice(poolPtr, poolPtr += 16); -} - -/***/ }), - -/***/ 8844: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _crypto = _interopRequireDefault(__nccwpck_require__(6113)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function sha1(bytes) { - if (Array.isArray(bytes)) { - bytes = Buffer.from(bytes); - } else if (typeof bytes === 'string') { - bytes = Buffer.from(bytes, 'utf8'); - } - - return _crypto.default.createHash('sha1').update(bytes).digest(); -} - -var _default = sha1; -exports["default"] = _default; - -/***/ }), - -/***/ 1458: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -/** - * Convert array of 16 byte values to UUID string format of the form: - * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - */ -const byteToHex = []; - -for (let i = 0; i < 256; ++i) { - byteToHex.push((i + 0x100).toString(16).substr(1)); -} - -function stringify(arr, offset = 0) { - // Note: Be careful editing this code! It's been tuned for performance - // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 - const uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one - // of the following: - // - One or more input array values don't map to a hex octet (leading to - // "undefined" in the uuid) - // - Invalid input values for the RFC `version` or `variant` fields - - if (!(0, _validate.default)(uuid)) { - throw TypeError('Stringified UUID is invalid'); - } - - return uuid; -} - -var _default = stringify; -exports["default"] = _default; - -/***/ }), - -/***/ 1595: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(9784)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html -let _nodeId; - -let _clockseq; // Previous uuid creation time - - -let _lastMSecs = 0; -let _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details - -function v1(options, buf, offset) { - let i = buf && offset || 0; - const b = buf || new Array(16); - options = options || {}; - let node = options.node || _nodeId; - let clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - - if (node == null || clockseq == null) { - const seedBytes = options.random || (options.rng || _rng.default)(); - - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; - } - - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - } - } // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - - - let msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - - let nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) - - const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression - - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - - - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } // Per 4.2.1.2 Throw error if too many uuids are requested - - - if (nsecs >= 10000) { - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - - msecs += 12219292800000; // `time_low` - - const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; // `time_mid` - - const tmh = msecs / 0x100000000 * 10000 & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; // `time_high_and_version` - - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - - b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - - b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` - - b[i++] = clockseq & 0xff; // `node` - - for (let n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf || (0, _stringify.default)(b); -} - -var _default = v1; -exports["default"] = _default; - -/***/ }), - -/***/ 6993: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(5920)); - -var _md = _interopRequireDefault(__nccwpck_require__(5842)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v3 = (0, _v.default)('v3', 0x30, _md.default); -var _default = v3; -exports["default"] = _default; - -/***/ }), - -/***/ 5920: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = _default; -exports.URL = exports.DNS = void 0; - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -var _parse = _interopRequireDefault(__nccwpck_require__(6385)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function stringToBytes(str) { - str = unescape(encodeURIComponent(str)); // UTF8 escape - - const bytes = []; - - for (let i = 0; i < str.length; ++i) { - bytes.push(str.charCodeAt(i)); - } - - return bytes; -} - -const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; -exports.DNS = DNS; -const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; -exports.URL = URL; - -function _default(name, version, hashfunc) { - function generateUUID(value, namespace, buf, offset) { - if (typeof value === 'string') { - value = stringToBytes(value); - } - - if (typeof namespace === 'string') { - namespace = (0, _parse.default)(namespace); - } - - if (namespace.length !== 16) { - throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); - } // Compute hash of namespace and value, Per 4.3 - // Future: Use spread syntax when supported on all platforms, e.g. `bytes = - // hashfunc([...namespace, ... value])` - - - let bytes = new Uint8Array(16 + value.length); - bytes.set(namespace); - bytes.set(value, namespace.length); - bytes = hashfunc(bytes); - bytes[6] = bytes[6] & 0x0f | version; - bytes[8] = bytes[8] & 0x3f | 0x80; - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = bytes[i]; - } - - return buf; - } - - return (0, _stringify.default)(bytes); - } // Function#name is not settable on some platforms (#270) - - - try { - generateUUID.name = name; // eslint-disable-next-line no-empty - } catch (err) {} // For CommonJS default export support - - - generateUUID.DNS = DNS; - generateUUID.URL = URL; - return generateUUID; -} - -/***/ }), - -/***/ 1472: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _rng = _interopRequireDefault(__nccwpck_require__(9784)); - -var _stringify = _interopRequireDefault(__nccwpck_require__(1458)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function v4(options, buf, offset) { - options = options || {}; - - const rnds = options.random || (options.rng || _rng.default)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` - - - rnds[6] = rnds[6] & 0x0f | 0x40; - rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided - - if (buf) { - offset = offset || 0; - - for (let i = 0; i < 16; ++i) { - buf[offset + i] = rnds[i]; - } - - return buf; - } - - return (0, _stringify.default)(rnds); -} - -var _default = v4; -exports["default"] = _default; - -/***/ }), - -/***/ 6217: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _v = _interopRequireDefault(__nccwpck_require__(5920)); - -var _sha = _interopRequireDefault(__nccwpck_require__(8844)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -const v5 = (0, _v.default)('v5', 0x50, _sha.default); -var _default = v5; -exports["default"] = _default; - -/***/ }), - -/***/ 2609: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _regex = _interopRequireDefault(__nccwpck_require__(6230)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function validate(uuid) { - return typeof uuid === 'string' && _regex.default.test(uuid); -} - -var _default = validate; -exports["default"] = _default; - -/***/ }), - -/***/ 427: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; - -var _validate = _interopRequireDefault(__nccwpck_require__(2609)); - -function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - -function version(uuid) { - if (!(0, _validate.default)(uuid)) { - throw TypeError('Invalid UUID'); - } - - return parseInt(uuid.substr(14, 1), 16); -} - -var _default = version; -exports["default"] = _default; - -/***/ }), - /***/ 1514: /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { @@ -51031,6 +52976,4940 @@ exports.VERSION = void 0; exports.VERSION = '1.7.0'; //# sourceMappingURL=version.js.map +/***/ }), + +/***/ 9912: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ClientStreamingCall = void 0; +/** + * A client streaming RPC call. This means that the clients sends 0, 1, or + * more messages to the server, and the server replies with exactly one + * message. + */ +class ClientStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.requests = request; + this.headers = headers; + this.response = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * Note that it may still be valid to send more request messages. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, response, status, trailers] = yield Promise.all([this.headers, this.response, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + headers, + response, + status, + trailers + }; + }); + } +} +exports.ClientStreamingCall = ClientStreamingCall; + + +/***/ }), + +/***/ 5702: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Deferred = exports.DeferredState = void 0; +var DeferredState; +(function (DeferredState) { + DeferredState[DeferredState["PENDING"] = 0] = "PENDING"; + DeferredState[DeferredState["REJECTED"] = 1] = "REJECTED"; + DeferredState[DeferredState["RESOLVED"] = 2] = "RESOLVED"; +})(DeferredState = exports.DeferredState || (exports.DeferredState = {})); +/** + * A deferred promise. This is a "controller" for a promise, which lets you + * pass a promise around and reject or resolve it from the outside. + * + * Warning: This class is to be used with care. Using it can make code very + * difficult to read. It is intended for use in library code that exposes + * promises, not for regular business logic. + */ +class Deferred { + /** + * @param preventUnhandledRejectionWarning - prevents the warning + * "Unhandled Promise rejection" by adding a noop rejection handler. + * Working with calls returned from the runtime-rpc package in an + * async function usually means awaiting one call property after + * the other. This means that the "status" is not being awaited when + * an earlier await for the "headers" is rejected. This causes the + * "unhandled promise reject" warning. A more correct behaviour for + * calls might be to become aware whether at least one of the + * promises is handled and swallow the rejection warning for the + * others. + */ + constructor(preventUnhandledRejectionWarning = true) { + this._state = DeferredState.PENDING; + this._promise = new Promise((resolve, reject) => { + this._resolve = resolve; + this._reject = reject; + }); + if (preventUnhandledRejectionWarning) { + this._promise.catch(_ => { }); + } + } + /** + * Get the current state of the promise. + */ + get state() { + return this._state; + } + /** + * Get the deferred promise. + */ + get promise() { + return this._promise; + } + /** + * Resolve the promise. Throws if the promise is already resolved or rejected. + */ + resolve(value) { + if (this.state !== DeferredState.PENDING) + throw new Error(`cannot resolve ${DeferredState[this.state].toLowerCase()}`); + this._resolve(value); + this._state = DeferredState.RESOLVED; + } + /** + * Reject the promise. Throws if the promise is already resolved or rejected. + */ + reject(reason) { + if (this.state !== DeferredState.PENDING) + throw new Error(`cannot reject ${DeferredState[this.state].toLowerCase()}`); + this._reject(reason); + this._state = DeferredState.REJECTED; + } + /** + * Resolve the promise. Ignore if not pending. + */ + resolvePending(val) { + if (this._state === DeferredState.PENDING) + this.resolve(val); + } + /** + * Reject the promise. Ignore if not pending. + */ + rejectPending(reason) { + if (this._state === DeferredState.PENDING) + this.reject(reason); + } +} +exports.Deferred = Deferred; + + +/***/ }), + +/***/ 7042: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.DuplexStreamingCall = void 0; +/** + * A duplex streaming RPC call. This means that the clients sends an + * arbitrary amount of messages to the server, while at the same time, + * the server sends an arbitrary amount of messages to the client. + */ +class DuplexStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.requests = request; + this.headers = headers; + this.responses = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * Note that it may still be valid to send more request messages. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, status, trailers] = yield Promise.all([this.headers, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + headers, + status, + trailers, + }; + }); + } +} +exports.DuplexStreamingCall = DuplexStreamingCall; + + +/***/ }), + +/***/ 12: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +// Public API of the rpc runtime. +// Note: we do not use `export * from ...` to help tree shakers, +// webpack verbose output hints that this should be useful +Object.defineProperty(exports, "__esModule", ({ value: true })); +var service_type_1 = __nccwpck_require__(4107); +Object.defineProperty(exports, "ServiceType", ({ enumerable: true, get: function () { return service_type_1.ServiceType; } })); +var reflection_info_1 = __nccwpck_require__(4331); +Object.defineProperty(exports, "readMethodOptions", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOptions; } })); +Object.defineProperty(exports, "readMethodOption", ({ enumerable: true, get: function () { return reflection_info_1.readMethodOption; } })); +Object.defineProperty(exports, "readServiceOption", ({ enumerable: true, get: function () { return reflection_info_1.readServiceOption; } })); +var rpc_error_1 = __nccwpck_require__(3159); +Object.defineProperty(exports, "RpcError", ({ enumerable: true, get: function () { return rpc_error_1.RpcError; } })); +var rpc_options_1 = __nccwpck_require__(7386); +Object.defineProperty(exports, "mergeRpcOptions", ({ enumerable: true, get: function () { return rpc_options_1.mergeRpcOptions; } })); +var rpc_output_stream_1 = __nccwpck_require__(6637); +Object.defineProperty(exports, "RpcOutputStreamController", ({ enumerable: true, get: function () { return rpc_output_stream_1.RpcOutputStreamController; } })); +var test_transport_1 = __nccwpck_require__(7008); +Object.defineProperty(exports, "TestTransport", ({ enumerable: true, get: function () { return test_transport_1.TestTransport; } })); +var deferred_1 = __nccwpck_require__(5702); +Object.defineProperty(exports, "Deferred", ({ enumerable: true, get: function () { return deferred_1.Deferred; } })); +Object.defineProperty(exports, "DeferredState", ({ enumerable: true, get: function () { return deferred_1.DeferredState; } })); +var duplex_streaming_call_1 = __nccwpck_require__(7042); +Object.defineProperty(exports, "DuplexStreamingCall", ({ enumerable: true, get: function () { return duplex_streaming_call_1.DuplexStreamingCall; } })); +var client_streaming_call_1 = __nccwpck_require__(9912); +Object.defineProperty(exports, "ClientStreamingCall", ({ enumerable: true, get: function () { return client_streaming_call_1.ClientStreamingCall; } })); +var server_streaming_call_1 = __nccwpck_require__(66); +Object.defineProperty(exports, "ServerStreamingCall", ({ enumerable: true, get: function () { return server_streaming_call_1.ServerStreamingCall; } })); +var unary_call_1 = __nccwpck_require__(164); +Object.defineProperty(exports, "UnaryCall", ({ enumerable: true, get: function () { return unary_call_1.UnaryCall; } })); +var rpc_interceptor_1 = __nccwpck_require__(1680); +Object.defineProperty(exports, "stackIntercept", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackIntercept; } })); +Object.defineProperty(exports, "stackDuplexStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackDuplexStreamingInterceptors; } })); +Object.defineProperty(exports, "stackClientStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackClientStreamingInterceptors; } })); +Object.defineProperty(exports, "stackServerStreamingInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackServerStreamingInterceptors; } })); +Object.defineProperty(exports, "stackUnaryInterceptors", ({ enumerable: true, get: function () { return rpc_interceptor_1.stackUnaryInterceptors; } })); +var server_call_context_1 = __nccwpck_require__(5320); +Object.defineProperty(exports, "ServerCallContextController", ({ enumerable: true, get: function () { return server_call_context_1.ServerCallContextController; } })); + + +/***/ }), + +/***/ 4331: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.readServiceOption = exports.readMethodOption = exports.readMethodOptions = exports.normalizeMethodInfo = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Turns PartialMethodInfo into MethodInfo. + */ +function normalizeMethodInfo(method, service) { + var _a, _b, _c; + let m = method; + m.service = service; + m.localName = (_a = m.localName) !== null && _a !== void 0 ? _a : runtime_1.lowerCamelCase(m.name); + // noinspection PointlessBooleanExpressionJS + m.serverStreaming = !!m.serverStreaming; + // noinspection PointlessBooleanExpressionJS + m.clientStreaming = !!m.clientStreaming; + m.options = (_b = m.options) !== null && _b !== void 0 ? _b : {}; + m.idempotency = (_c = m.idempotency) !== null && _c !== void 0 ? _c : undefined; + return m; +} +exports.normalizeMethodInfo = normalizeMethodInfo; +/** + * Read custom method options from a generated service client. + * + * @deprecated use readMethodOption() + */ +function readMethodOptions(service, methodName, extensionName, extensionType) { + var _a; + const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options; + return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : undefined; +} +exports.readMethodOptions = readMethodOptions; +function readMethodOption(service, methodName, extensionName, extensionType) { + var _a; + const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readMethodOption = readMethodOption; +function readServiceOption(service, extensionName, extensionType) { + const options = service.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readServiceOption = readServiceOption; + + +/***/ }), + +/***/ 3159: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.RpcError = void 0; +/** + * An error that occurred while calling a RPC method. + */ +class RpcError extends Error { + constructor(message, code = 'UNKNOWN', meta) { + super(message); + this.name = 'RpcError'; + // see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#example + Object.setPrototypeOf(this, new.target.prototype); + this.code = code; + this.meta = meta !== null && meta !== void 0 ? meta : {}; + } + toString() { + const l = [this.name + ': ' + this.message]; + if (this.code) { + l.push(''); + l.push('Code: ' + this.code); + } + if (this.serviceName && this.methodName) { + l.push('Method: ' + this.serviceName + '/' + this.methodName); + } + let m = Object.entries(this.meta); + if (m.length) { + l.push(''); + l.push('Meta:'); + for (let [k, v] of m) { + l.push(` ${k}: ${v}`); + } + } + return l.join('\n'); + } +} +exports.RpcError = RpcError; + + +/***/ }), + +/***/ 1680: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.stackDuplexStreamingInterceptors = exports.stackClientStreamingInterceptors = exports.stackServerStreamingInterceptors = exports.stackUnaryInterceptors = exports.stackIntercept = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Creates a "stack" of of all interceptors specified in the given `RpcOptions`. + * Used by generated client implementations. + * @internal + */ +function stackIntercept(kind, transport, method, options, input) { + var _a, _b, _c, _d; + if (kind == "unary") { + let tail = (mtd, inp, opt) => transport.unary(mtd, inp, opt); + for (const curr of ((_a = options.interceptors) !== null && _a !== void 0 ? _a : []).filter(i => i.interceptUnary).reverse()) { + const next = tail; + tail = (mtd, inp, opt) => curr.interceptUnary(next, mtd, inp, opt); + } + return tail(method, input, options); + } + if (kind == "serverStreaming") { + let tail = (mtd, inp, opt) => transport.serverStreaming(mtd, inp, opt); + for (const curr of ((_b = options.interceptors) !== null && _b !== void 0 ? _b : []).filter(i => i.interceptServerStreaming).reverse()) { + const next = tail; + tail = (mtd, inp, opt) => curr.interceptServerStreaming(next, mtd, inp, opt); + } + return tail(method, input, options); + } + if (kind == "clientStreaming") { + let tail = (mtd, opt) => transport.clientStreaming(mtd, opt); + for (const curr of ((_c = options.interceptors) !== null && _c !== void 0 ? _c : []).filter(i => i.interceptClientStreaming).reverse()) { + const next = tail; + tail = (mtd, opt) => curr.interceptClientStreaming(next, mtd, opt); + } + return tail(method, options); + } + if (kind == "duplex") { + let tail = (mtd, opt) => transport.duplex(mtd, opt); + for (const curr of ((_d = options.interceptors) !== null && _d !== void 0 ? _d : []).filter(i => i.interceptDuplex).reverse()) { + const next = tail; + tail = (mtd, opt) => curr.interceptDuplex(next, mtd, opt); + } + return tail(method, options); + } + runtime_1.assertNever(kind); +} +exports.stackIntercept = stackIntercept; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackUnaryInterceptors(transport, method, input, options) { + return stackIntercept("unary", transport, method, options, input); +} +exports.stackUnaryInterceptors = stackUnaryInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackServerStreamingInterceptors(transport, method, input, options) { + return stackIntercept("serverStreaming", transport, method, options, input); +} +exports.stackServerStreamingInterceptors = stackServerStreamingInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackClientStreamingInterceptors(transport, method, options) { + return stackIntercept("clientStreaming", transport, method, options); +} +exports.stackClientStreamingInterceptors = stackClientStreamingInterceptors; +/** + * @deprecated replaced by `stackIntercept()`, still here to support older generated code + */ +function stackDuplexStreamingInterceptors(transport, method, options) { + return stackIntercept("duplex", transport, method, options); +} +exports.stackDuplexStreamingInterceptors = stackDuplexStreamingInterceptors; + + +/***/ }), + +/***/ 7386: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.mergeRpcOptions = void 0; +const runtime_1 = __nccwpck_require__(4061); +/** + * Merges custom RPC options with defaults. Returns a new instance and keeps + * the "defaults" and the "options" unmodified. + * + * Merges `RpcMetadata` "meta", overwriting values from "defaults" with + * values from "options". Does not append values to existing entries. + * + * Merges "jsonOptions", including "jsonOptions.typeRegistry", by creating + * a new array that contains types from "options.jsonOptions.typeRegistry" + * first, then types from "defaults.jsonOptions.typeRegistry". + * + * Merges "binaryOptions". + * + * Merges "interceptors" by creating a new array that contains interceptors + * from "defaults" first, then interceptors from "options". + * + * Works with objects that extend `RpcOptions`, but only if the added + * properties are of type Date, primitive like string, boolean, or Array + * of primitives. If you have other property types, you have to merge them + * yourself. + */ +function mergeRpcOptions(defaults, options) { + if (!options) + return defaults; + let o = {}; + copy(defaults, o); + copy(options, o); + for (let key of Object.keys(options)) { + let val = options[key]; + switch (key) { + case "jsonOptions": + o.jsonOptions = runtime_1.mergeJsonOptions(defaults.jsonOptions, o.jsonOptions); + break; + case "binaryOptions": + o.binaryOptions = runtime_1.mergeBinaryOptions(defaults.binaryOptions, o.binaryOptions); + break; + case "meta": + o.meta = {}; + copy(defaults.meta, o.meta); + copy(options.meta, o.meta); + break; + case "interceptors": + o.interceptors = defaults.interceptors ? defaults.interceptors.concat(val) : val.concat(); + break; + } + } + return o; +} +exports.mergeRpcOptions = mergeRpcOptions; +function copy(a, into) { + if (!a) + return; + let c = into; + for (let [k, v] of Object.entries(a)) { + if (v instanceof Date) + c[k] = new Date(v.getTime()); + else if (Array.isArray(v)) + c[k] = v.concat(); + else + c[k] = v; + } +} + + +/***/ }), + +/***/ 6637: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.RpcOutputStreamController = void 0; +const deferred_1 = __nccwpck_require__(5702); +const runtime_1 = __nccwpck_require__(4061); +/** + * A `RpcOutputStream` that you control. + */ +class RpcOutputStreamController { + constructor() { + this._lis = { + nxt: [], + msg: [], + err: [], + cmp: [], + }; + this._closed = false; + } + // --- RpcOutputStream callback API + onNext(callback) { + return this.addLis(callback, this._lis.nxt); + } + onMessage(callback) { + return this.addLis(callback, this._lis.msg); + } + onError(callback) { + return this.addLis(callback, this._lis.err); + } + onComplete(callback) { + return this.addLis(callback, this._lis.cmp); + } + addLis(callback, list) { + list.push(callback); + return () => { + let i = list.indexOf(callback); + if (i >= 0) + list.splice(i, 1); + }; + } + // remove all listeners + clearLis() { + for (let l of Object.values(this._lis)) + l.splice(0, l.length); + } + // --- Controller API + /** + * Is this stream already closed by a completion or error? + */ + get closed() { + return this._closed !== false; + } + /** + * Emit message, close with error, or close successfully, but only one + * at a time. + * Can be used to wrap a stream by using the other stream's `onNext`. + */ + notifyNext(message, error, complete) { + runtime_1.assert((message ? 1 : 0) + (error ? 1 : 0) + (complete ? 1 : 0) <= 1, 'only one emission at a time'); + if (message) + this.notifyMessage(message); + if (error) + this.notifyError(error); + if (complete) + this.notifyComplete(); + } + /** + * Emits a new message. Throws if stream is closed. + * + * Triggers onNext and onMessage callbacks. + */ + notifyMessage(message) { + runtime_1.assert(!this.closed, 'stream is closed'); + this.pushIt({ value: message, done: false }); + this._lis.msg.forEach(l => l(message)); + this._lis.nxt.forEach(l => l(message, undefined, false)); + } + /** + * Closes the stream with an error. Throws if stream is closed. + * + * Triggers onNext and onError callbacks. + */ + notifyError(error) { + runtime_1.assert(!this.closed, 'stream is closed'); + this._closed = error; + this.pushIt(error); + this._lis.err.forEach(l => l(error)); + this._lis.nxt.forEach(l => l(undefined, error, false)); + this.clearLis(); + } + /** + * Closes the stream successfully. Throws if stream is closed. + * + * Triggers onNext and onComplete callbacks. + */ + notifyComplete() { + runtime_1.assert(!this.closed, 'stream is closed'); + this._closed = true; + this.pushIt({ value: null, done: true }); + this._lis.cmp.forEach(l => l()); + this._lis.nxt.forEach(l => l(undefined, undefined, true)); + this.clearLis(); + } + /** + * Creates an async iterator (that can be used with `for await {...}`) + * to consume the stream. + * + * Some things to note: + * - If an error occurs, the `for await` will throw it. + * - If an error occurred before the `for await` was started, `for await` + * will re-throw it. + * - If the stream is already complete, the `for await` will be empty. + * - If your `for await` consumes slower than the stream produces, + * for example because you are relaying messages in a slow operation, + * messages are queued. + */ + [Symbol.asyncIterator]() { + // init the iterator state, enabling pushIt() + if (!this._itState) { + this._itState = { q: [] }; + } + // if we are closed, we are definitely not receiving any more messages. + // but we can't let the iterator get stuck. we want to either: + // a) finish the new iterator immediately, because we are completed + // b) reject the new iterator, because we errored + if (this._closed === true) + this.pushIt({ value: null, done: true }); + else if (this._closed !== false) + this.pushIt(this._closed); + // the async iterator + return { + next: () => { + let state = this._itState; + runtime_1.assert(state, "bad state"); // if we don't have a state here, code is broken + // there should be no pending result. + // did the consumer call next() before we resolved our previous result promise? + runtime_1.assert(!state.p, "iterator contract broken"); + // did we produce faster than the iterator consumed? + // return the oldest result from the queue. + let first = state.q.shift(); + if (first) + return ("value" in first) ? Promise.resolve(first) : Promise.reject(first); + // we have no result ATM, but we promise one. + // as soon as we have a result, we must resolve promise. + state.p = new deferred_1.Deferred(); + return state.p.promise; + }, + }; + } + // "push" a new iterator result. + // this either resolves a pending promise, or enqueues the result. + pushIt(result) { + let state = this._itState; + if (!state) + return; + // is the consumer waiting for us? + if (state.p) { + // yes, consumer is waiting for this promise. + const p = state.p; + runtime_1.assert(p.state == deferred_1.DeferredState.PENDING, "iterator contract broken"); + // resolve the promise + ("value" in result) ? p.resolve(result) : p.reject(result); + // must cleanup, otherwise iterator.next() would pick it up again. + delete state.p; + } + else { + // we are producing faster than the iterator consumes. + // push result onto queue. + state.q.push(result); + } + } +} +exports.RpcOutputStreamController = RpcOutputStreamController; + + +/***/ }), + +/***/ 5320: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServerCallContextController = void 0; +class ServerCallContextController { + constructor(method, headers, deadline, sendResponseHeadersFn, defaultStatus = { code: 'OK', detail: '' }) { + this._cancelled = false; + this._listeners = []; + this.method = method; + this.headers = headers; + this.deadline = deadline; + this.trailers = {}; + this._sendRH = sendResponseHeadersFn; + this.status = defaultStatus; + } + /** + * Set the call cancelled. + * + * Invokes all callbacks registered with onCancel() and + * sets `cancelled = true`. + */ + notifyCancelled() { + if (!this._cancelled) { + this._cancelled = true; + for (let l of this._listeners) { + l(); + } + } + } + /** + * Send response headers. + */ + sendResponseHeaders(data) { + this._sendRH(data); + } + /** + * Is the call cancelled? + * + * When the client closes the connection before the server + * is done, the call is cancelled. + * + * If you want to cancel a request on the server, throw a + * RpcError with the CANCELLED status code. + */ + get cancelled() { + return this._cancelled; + } + /** + * Add a callback for cancellation. + */ + onCancel(callback) { + const l = this._listeners; + l.push(callback); + return () => { + let i = l.indexOf(callback); + if (i >= 0) + l.splice(i, 1); + }; + } +} +exports.ServerCallContextController = ServerCallContextController; + + +/***/ }), + +/***/ 66: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServerStreamingCall = void 0; +/** + * A server streaming RPC call. The client provides exactly one input message + * but the server may respond with 0, 1, or more messages. + */ +class ServerStreamingCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.request = request; + this.headers = headers; + this.responses = response; + this.status = status; + this.trailers = trailers; + } + /** + * Instead of awaiting the response status and trailers, you can + * just as well await this call itself to receive the server outcome. + * You should first setup some listeners to the `request` to + * see the actual messages the server replied with. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, status, trailers] = yield Promise.all([this.headers, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + request: this.request, + headers, + status, + trailers, + }; + }); + } +} +exports.ServerStreamingCall = ServerStreamingCall; + + +/***/ }), + +/***/ 4107: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ServiceType = void 0; +const reflection_info_1 = __nccwpck_require__(4331); +class ServiceType { + constructor(typeName, methods, options) { + this.typeName = typeName; + this.methods = methods.map(i => reflection_info_1.normalizeMethodInfo(i, this)); + this.options = options !== null && options !== void 0 ? options : {}; + } +} +exports.ServiceType = ServiceType; + + +/***/ }), + +/***/ 7008: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TestTransport = void 0; +const rpc_error_1 = __nccwpck_require__(3159); +const runtime_1 = __nccwpck_require__(4061); +const rpc_output_stream_1 = __nccwpck_require__(6637); +const rpc_options_1 = __nccwpck_require__(7386); +const unary_call_1 = __nccwpck_require__(164); +const server_streaming_call_1 = __nccwpck_require__(66); +const client_streaming_call_1 = __nccwpck_require__(9912); +const duplex_streaming_call_1 = __nccwpck_require__(7042); +/** + * Transport for testing. + */ +class TestTransport { + /** + * Initialize with mock data. Omitted fields have default value. + */ + constructor(data) { + /** + * Suppress warning / error about uncaught rejections of + * "status" and "trailers". + */ + this.suppressUncaughtRejections = true; + this.headerDelay = 10; + this.responseDelay = 50; + this.betweenResponseDelay = 10; + this.afterResponseDelay = 10; + this.data = data !== null && data !== void 0 ? data : {}; + } + /** + * Sent message(s) during the last operation. + */ + get sentMessages() { + if (this.lastInput instanceof TestInputStream) { + return this.lastInput.sent; + } + else if (typeof this.lastInput == "object") { + return [this.lastInput.single]; + } + return []; + } + /** + * Sending message(s) completed? + */ + get sendComplete() { + if (this.lastInput instanceof TestInputStream) { + return this.lastInput.completed; + } + else if (typeof this.lastInput == "object") { + return true; + } + return false; + } + // Creates a promise for response headers from the mock data. + promiseHeaders() { + var _a; + const headers = (_a = this.data.headers) !== null && _a !== void 0 ? _a : TestTransport.defaultHeaders; + return headers instanceof rpc_error_1.RpcError + ? Promise.reject(headers) + : Promise.resolve(headers); + } + // Creates a promise for a single, valid, message from the mock data. + promiseSingleResponse(method) { + if (this.data.response instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.response); + } + let r; + if (Array.isArray(this.data.response)) { + runtime_1.assert(this.data.response.length > 0); + r = this.data.response[0]; + } + else if (this.data.response !== undefined) { + r = this.data.response; + } + else { + r = method.O.create(); + } + runtime_1.assert(method.O.is(r)); + return Promise.resolve(r); + } + /** + * Pushes response messages from the mock data to the output stream. + * If an error response, status or trailers are mocked, the stream is + * closed with the respective error. + * Otherwise, stream is completed successfully. + * + * The returned promise resolves when the stream is closed. It should + * not reject. If it does, code is broken. + */ + streamResponses(method, stream, abort) { + return __awaiter(this, void 0, void 0, function* () { + // normalize "data.response" into an array of valid output messages + const messages = []; + if (this.data.response === undefined) { + messages.push(method.O.create()); + } + else if (Array.isArray(this.data.response)) { + for (let msg of this.data.response) { + runtime_1.assert(method.O.is(msg)); + messages.push(msg); + } + } + else if (!(this.data.response instanceof rpc_error_1.RpcError)) { + runtime_1.assert(method.O.is(this.data.response)); + messages.push(this.data.response); + } + // start the stream with an initial delay. + // if the request is cancelled, notify() error and exit. + try { + yield delay(this.responseDelay, abort)(undefined); + } + catch (error) { + stream.notifyError(error); + return; + } + // if error response was mocked, notify() error (stream is now closed with error) and exit. + if (this.data.response instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.response); + return; + } + // regular response messages were mocked. notify() them. + for (let msg of messages) { + stream.notifyMessage(msg); + // add a short delay between responses + // if the request is cancelled, notify() error and exit. + try { + yield delay(this.betweenResponseDelay, abort)(undefined); + } + catch (error) { + stream.notifyError(error); + return; + } + } + // error status was mocked, notify() error (stream is now closed with error) and exit. + if (this.data.status instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.status); + return; + } + // error trailers were mocked, notify() error (stream is now closed with error) and exit. + if (this.data.trailers instanceof rpc_error_1.RpcError) { + stream.notifyError(this.data.trailers); + return; + } + // stream completed successfully + stream.notifyComplete(); + }); + } + // Creates a promise for response status from the mock data. + promiseStatus() { + var _a; + const status = (_a = this.data.status) !== null && _a !== void 0 ? _a : TestTransport.defaultStatus; + return status instanceof rpc_error_1.RpcError + ? Promise.reject(status) + : Promise.resolve(status); + } + // Creates a promise for response trailers from the mock data. + promiseTrailers() { + var _a; + const trailers = (_a = this.data.trailers) !== null && _a !== void 0 ? _a : TestTransport.defaultTrailers; + return trailers instanceof rpc_error_1.RpcError + ? Promise.reject(trailers) + : Promise.resolve(trailers); + } + maybeSuppressUncaught(...promise) { + if (this.suppressUncaughtRejections) { + for (let p of promise) { + p.catch(() => { + }); + } + } + } + mergeOptions(options) { + return rpc_options_1.mergeRpcOptions({}, options); + } + unary(method, input, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), responsePromise = headersPromise + .catch(_ => { + }) + .then(delay(this.responseDelay, options.abort)) + .then(_ => this.promiseSingleResponse(method)), statusPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseStatus()), trailersPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = { single: input }; + return new unary_call_1.UnaryCall(method, requestHeaders, input, headersPromise, responsePromise, statusPromise, trailersPromise); + } + serverStreaming(method, input, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise + .then(delay(this.responseDelay, options.abort)) + .catch(() => { + }) + .then(() => this.streamResponses(method, outputStream, options.abort)) + .then(delay(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise + .then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise + .then(() => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = { single: input }; + return new server_streaming_call_1.ServerStreamingCall(method, requestHeaders, input, headersPromise, outputStream, statusPromise, trailersPromise); + } + clientStreaming(method, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), responsePromise = headersPromise + .catch(_ => { + }) + .then(delay(this.responseDelay, options.abort)) + .then(_ => this.promiseSingleResponse(method)), statusPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseStatus()), trailersPromise = responsePromise + .catch(_ => { + }) + .then(delay(this.afterResponseDelay, options.abort)) + .then(_ => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = new TestInputStream(this.data, options.abort); + return new client_streaming_call_1.ClientStreamingCall(method, requestHeaders, this.lastInput, headersPromise, responsePromise, statusPromise, trailersPromise); + } + duplex(method, options) { + var _a; + const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders() + .then(delay(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise + .then(delay(this.responseDelay, options.abort)) + .catch(() => { + }) + .then(() => this.streamResponses(method, outputStream, options.abort)) + .then(delay(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise + .then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise + .then(() => this.promiseTrailers()); + this.maybeSuppressUncaught(statusPromise, trailersPromise); + this.lastInput = new TestInputStream(this.data, options.abort); + return new duplex_streaming_call_1.DuplexStreamingCall(method, requestHeaders, this.lastInput, headersPromise, outputStream, statusPromise, trailersPromise); + } +} +exports.TestTransport = TestTransport; +TestTransport.defaultHeaders = { + responseHeader: "test" +}; +TestTransport.defaultStatus = { + code: "OK", detail: "all good" +}; +TestTransport.defaultTrailers = { + responseTrailer: "test" +}; +function delay(ms, abort) { + return (v) => new Promise((resolve, reject) => { + if (abort === null || abort === void 0 ? void 0 : abort.aborted) { + reject(new rpc_error_1.RpcError("user cancel", "CANCELLED")); + } + else { + const id = setTimeout(() => resolve(v), ms); + if (abort) { + abort.addEventListener("abort", ev => { + clearTimeout(id); + reject(new rpc_error_1.RpcError("user cancel", "CANCELLED")); + }); + } + } + }); +} +class TestInputStream { + constructor(data, abort) { + this._completed = false; + this._sent = []; + this.data = data; + this.abort = abort; + } + get sent() { + return this._sent; + } + get completed() { + return this._completed; + } + send(message) { + if (this.data.inputMessage instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.inputMessage); + } + const delayMs = this.data.inputMessage === undefined + ? 10 + : this.data.inputMessage; + return Promise.resolve(undefined) + .then(() => { + this._sent.push(message); + }) + .then(delay(delayMs, this.abort)); + } + complete() { + if (this.data.inputComplete instanceof rpc_error_1.RpcError) { + return Promise.reject(this.data.inputComplete); + } + const delayMs = this.data.inputComplete === undefined + ? 10 + : this.data.inputComplete; + return Promise.resolve(undefined) + .then(() => { + this._completed = true; + }) + .then(delay(delayMs, this.abort)); + } +} + + +/***/ }), + +/***/ 164: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.UnaryCall = void 0; +/** + * A unary RPC call. Unary means there is exactly one input message and + * exactly one output message unless an error occurred. + */ +class UnaryCall { + constructor(method, requestHeaders, request, headers, response, status, trailers) { + this.method = method; + this.requestHeaders = requestHeaders; + this.request = request; + this.headers = headers; + this.response = response; + this.status = status; + this.trailers = trailers; + } + /** + * If you are only interested in the final outcome of this call, + * you can await it to receive a `FinishedUnaryCall`. + */ + then(onfulfilled, onrejected) { + return this.promiseFinished().then(value => onfulfilled ? Promise.resolve(onfulfilled(value)) : value, reason => onrejected ? Promise.resolve(onrejected(reason)) : Promise.reject(reason)); + } + promiseFinished() { + return __awaiter(this, void 0, void 0, function* () { + let [headers, response, status, trailers] = yield Promise.all([this.headers, this.response, this.status, this.trailers]); + return { + method: this.method, + requestHeaders: this.requestHeaders, + request: this.request, + headers, + response, + status, + trailers + }; + }); + } +} +exports.UnaryCall = UnaryCall; + + +/***/ }), + +/***/ 4253: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.assertFloat32 = exports.assertUInt32 = exports.assertInt32 = exports.assertNever = exports.assert = void 0; +/** + * assert that condition is true or throw error (with message) + */ +function assert(condition, msg) { + if (!condition) { + throw new Error(msg); + } +} +exports.assert = assert; +/** + * assert that value cannot exist = type `never`. throw runtime error if it does. + */ +function assertNever(value, msg) { + throw new Error(msg !== null && msg !== void 0 ? msg : 'Unexpected object: ' + value); +} +exports.assertNever = assertNever; +const FLOAT32_MAX = 3.4028234663852886e+38, FLOAT32_MIN = -3.4028234663852886e+38, UINT32_MAX = 0xFFFFFFFF, INT32_MAX = 0X7FFFFFFF, INT32_MIN = -0X80000000; +function assertInt32(arg) { + if (typeof arg !== "number") + throw new Error('invalid int 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN) + throw new Error('invalid int 32: ' + arg); +} +exports.assertInt32 = assertInt32; +function assertUInt32(arg) { + if (typeof arg !== "number") + throw new Error('invalid uint 32: ' + typeof arg); + if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0) + throw new Error('invalid uint 32: ' + arg); +} +exports.assertUInt32 = assertUInt32; +function assertFloat32(arg) { + if (typeof arg !== "number") + throw new Error('invalid float 32: ' + typeof arg); + if (!Number.isFinite(arg)) + return; + if (arg > FLOAT32_MAX || arg < FLOAT32_MIN) + throw new Error('invalid float 32: ' + arg); +} +exports.assertFloat32 = assertFloat32; + + +/***/ }), + +/***/ 196: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.base64encode = exports.base64decode = void 0; +// lookup table from base64 character to byte +let encTable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(''); +// lookup table from base64 character *code* to byte because lookup by number is fast +let decTable = []; +for (let i = 0; i < encTable.length; i++) + decTable[encTable[i].charCodeAt(0)] = i; +// support base64url variants +decTable["-".charCodeAt(0)] = encTable.indexOf("+"); +decTable["_".charCodeAt(0)] = encTable.indexOf("/"); +/** + * Decodes a base64 string to a byte array. + * + * - ignores white-space, including line breaks and tabs + * - allows inner padding (can decode concatenated base64 strings) + * - does not require padding + * - understands base64url encoding: + * "-" instead of "+", + * "_" instead of "/", + * no padding + */ +function base64decode(base64Str) { + // estimate byte size, not accounting for inner padding and whitespace + let es = base64Str.length * 3 / 4; + // if (es % 3 !== 0) + // throw new Error('invalid base64 string'); + if (base64Str[base64Str.length - 2] == '=') + es -= 2; + else if (base64Str[base64Str.length - 1] == '=') + es -= 1; + let bytes = new Uint8Array(es), bytePos = 0, // position in byte array + groupPos = 0, // position in base64 group + b, // current byte + p = 0 // previous byte + ; + for (let i = 0; i < base64Str.length; i++) { + b = decTable[base64Str.charCodeAt(i)]; + if (b === undefined) { + // noinspection FallThroughInSwitchStatementJS + switch (base64Str[i]) { + case '=': + groupPos = 0; // reset state when padding found + case '\n': + case '\r': + case '\t': + case ' ': + continue; // skip white-space, and padding + default: + throw Error(`invalid base64 string.`); + } + } + switch (groupPos) { + case 0: + p = b; + groupPos = 1; + break; + case 1: + bytes[bytePos++] = p << 2 | (b & 48) >> 4; + p = b; + groupPos = 2; + break; + case 2: + bytes[bytePos++] = (p & 15) << 4 | (b & 60) >> 2; + p = b; + groupPos = 3; + break; + case 3: + bytes[bytePos++] = (p & 3) << 6 | b; + groupPos = 0; + break; + } + } + if (groupPos == 1) + throw Error(`invalid base64 string.`); + return bytes.subarray(0, bytePos); +} +exports.base64decode = base64decode; +/** + * Encodes a byte array to a base64 string. + * Adds padding at the end. + * Does not insert newlines. + */ +function base64encode(bytes) { + let base64 = '', groupPos = 0, // position in base64 group + b, // current byte + p = 0; // carry over from previous byte + for (let i = 0; i < bytes.length; i++) { + b = bytes[i]; + switch (groupPos) { + case 0: + base64 += encTable[b >> 2]; + p = (b & 3) << 4; + groupPos = 1; + break; + case 1: + base64 += encTable[p | b >> 4]; + p = (b & 15) << 2; + groupPos = 2; + break; + case 2: + base64 += encTable[p | b >> 6]; + base64 += encTable[b & 63]; + groupPos = 0; + break; + } + } + // padding required? + if (groupPos) { + base64 += encTable[p]; + base64 += '='; + if (groupPos == 1) + base64 += '='; + } + return base64; +} +exports.base64encode = base64encode; + + +/***/ }), + +/***/ 4921: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.WireType = exports.mergeBinaryOptions = exports.UnknownFieldHandler = void 0; +/** + * This handler implements the default behaviour for unknown fields. + * When reading data, unknown fields are stored on the message, in a + * symbol property. + * When writing data, the symbol property is queried and unknown fields + * are serialized into the output again. + */ +var UnknownFieldHandler; +(function (UnknownFieldHandler) { + /** + * The symbol used to store unknown fields for a message. + * The property must conform to `UnknownFieldContainer`. + */ + UnknownFieldHandler.symbol = Symbol.for("protobuf-ts/unknown"); + /** + * Store an unknown field during binary read directly on the message. + * This method is compatible with `BinaryReadOptions.readUnknownField`. + */ + UnknownFieldHandler.onRead = (typeName, message, fieldNo, wireType, data) => { + let container = is(message) ? message[UnknownFieldHandler.symbol] : message[UnknownFieldHandler.symbol] = []; + container.push({ no: fieldNo, wireType, data }); + }; + /** + * Write unknown fields stored for the message to the writer. + * This method is compatible with `BinaryWriteOptions.writeUnknownFields`. + */ + UnknownFieldHandler.onWrite = (typeName, message, writer) => { + for (let { no, wireType, data } of UnknownFieldHandler.list(message)) + writer.tag(no, wireType).raw(data); + }; + /** + * List unknown fields stored for the message. + * Note that there may be multiples fields with the same number. + */ + UnknownFieldHandler.list = (message, fieldNo) => { + if (is(message)) { + let all = message[UnknownFieldHandler.symbol]; + return fieldNo ? all.filter(uf => uf.no == fieldNo) : all; + } + return []; + }; + /** + * Returns the last unknown field by field number. + */ + UnknownFieldHandler.last = (message, fieldNo) => UnknownFieldHandler.list(message, fieldNo).slice(-1)[0]; + const is = (message) => message && Array.isArray(message[UnknownFieldHandler.symbol]); +})(UnknownFieldHandler = exports.UnknownFieldHandler || (exports.UnknownFieldHandler = {})); +/** + * Merges binary write or read options. Later values override earlier values. + */ +function mergeBinaryOptions(a, b) { + return Object.assign(Object.assign({}, a), b); +} +exports.mergeBinaryOptions = mergeBinaryOptions; +/** + * Protobuf binary format wire types. + * + * A wire type provides just enough information to find the length of the + * following value. + * + * See https://developers.google.com/protocol-buffers/docs/encoding#structure + */ +var WireType; +(function (WireType) { + /** + * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum + */ + WireType[WireType["Varint"] = 0] = "Varint"; + /** + * Used for fixed64, sfixed64, double. + * Always 8 bytes with little-endian byte order. + */ + WireType[WireType["Bit64"] = 1] = "Bit64"; + /** + * Used for string, bytes, embedded messages, packed repeated fields + * + * Only repeated numeric types (types which use the varint, 32-bit, + * or 64-bit wire types) can be packed. In proto3, such fields are + * packed by default. + */ + WireType[WireType["LengthDelimited"] = 2] = "LengthDelimited"; + /** + * Used for groups + * @deprecated + */ + WireType[WireType["StartGroup"] = 3] = "StartGroup"; + /** + * Used for groups + * @deprecated + */ + WireType[WireType["EndGroup"] = 4] = "EndGroup"; + /** + * Used for fixed32, sfixed32, float. + * Always 4 bytes with little-endian byte order. + */ + WireType[WireType["Bit32"] = 5] = "Bit32"; +})(WireType = exports.WireType || (exports.WireType = {})); + + +/***/ }), + +/***/ 5210: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BinaryReader = exports.binaryReadOptions = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const pb_long_1 = __nccwpck_require__(7777); +const goog_varint_1 = __nccwpck_require__(433); +const defaultsRead = { + readUnknownField: true, + readerFactory: bytes => new BinaryReader(bytes), +}; +/** + * Make options for reading binary data form partial options. + */ +function binaryReadOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead; +} +exports.binaryReadOptions = binaryReadOptions; +class BinaryReader { + constructor(buf, textDecoder) { + this.varint64 = goog_varint_1.varint64read; // dirty cast for `this` + /** + * Read a `uint32` field, an unsigned 32 bit varint. + */ + this.uint32 = goog_varint_1.varint32read; // dirty cast for `this` and access to protected `buf` + this.buf = buf; + this.len = buf.length; + this.pos = 0; + this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength); + this.textDecoder = textDecoder !== null && textDecoder !== void 0 ? textDecoder : new TextDecoder("utf-8", { + fatal: true, + ignoreBOM: true, + }); + } + /** + * Reads a tag - field number and wire type. + */ + tag() { + let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7; + if (fieldNo <= 0 || wireType < 0 || wireType > 5) + throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType); + return [fieldNo, wireType]; + } + /** + * Skip one element on the wire and return the skipped data. + * Supports WireType.StartGroup since v2.0.0-alpha.23. + */ + skip(wireType) { + let start = this.pos; + // noinspection FallThroughInSwitchStatementJS + switch (wireType) { + case binary_format_contract_1.WireType.Varint: + while (this.buf[this.pos++] & 0x80) { + // ignore + } + break; + case binary_format_contract_1.WireType.Bit64: + this.pos += 4; + case binary_format_contract_1.WireType.Bit32: + this.pos += 4; + break; + case binary_format_contract_1.WireType.LengthDelimited: + let len = this.uint32(); + this.pos += len; + break; + case binary_format_contract_1.WireType.StartGroup: + // From descriptor.proto: Group type is deprecated, not supported in proto3. + // But we must still be able to parse and treat as unknown. + let t; + while ((t = this.tag()[1]) !== binary_format_contract_1.WireType.EndGroup) { + this.skip(t); + } + break; + default: + throw new Error("cant skip wire type " + wireType); + } + this.assertBounds(); + return this.buf.subarray(start, this.pos); + } + /** + * Throws error if position in byte array is out of range. + */ + assertBounds() { + if (this.pos > this.len) + throw new RangeError("premature EOF"); + } + /** + * Read a `int32` field, a signed 32 bit varint. + */ + int32() { + return this.uint32() | 0; + } + /** + * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint. + */ + sint32() { + let zze = this.uint32(); + // decode zigzag + return (zze >>> 1) ^ -(zze & 1); + } + /** + * Read a `int64` field, a signed 64-bit varint. + */ + int64() { + return new pb_long_1.PbLong(...this.varint64()); + } + /** + * Read a `uint64` field, an unsigned 64-bit varint. + */ + uint64() { + return new pb_long_1.PbULong(...this.varint64()); + } + /** + * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint. + */ + sint64() { + let [lo, hi] = this.varint64(); + // decode zig zag + let s = -(lo & 1); + lo = ((lo >>> 1 | (hi & 1) << 31) ^ s); + hi = (hi >>> 1 ^ s); + return new pb_long_1.PbLong(lo, hi); + } + /** + * Read a `bool` field, a variant. + */ + bool() { + let [lo, hi] = this.varint64(); + return lo !== 0 || hi !== 0; + } + /** + * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer. + */ + fixed32() { + return this.view.getUint32((this.pos += 4) - 4, true); + } + /** + * Read a `sfixed32` field, a signed, fixed-length 32-bit integer. + */ + sfixed32() { + return this.view.getInt32((this.pos += 4) - 4, true); + } + /** + * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer. + */ + fixed64() { + return new pb_long_1.PbULong(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `fixed64` field, a signed, fixed-length 64-bit integer. + */ + sfixed64() { + return new pb_long_1.PbLong(this.sfixed32(), this.sfixed32()); + } + /** + * Read a `float` field, 32-bit floating point number. + */ + float() { + return this.view.getFloat32((this.pos += 4) - 4, true); + } + /** + * Read a `double` field, a 64-bit floating point number. + */ + double() { + return this.view.getFloat64((this.pos += 8) - 8, true); + } + /** + * Read a `bytes` field, length-delimited arbitrary data. + */ + bytes() { + let len = this.uint32(); + let start = this.pos; + this.pos += len; + this.assertBounds(); + return this.buf.subarray(start, start + len); + } + /** + * Read a `string` field, length-delimited data converted to UTF-8 text. + */ + string() { + return this.textDecoder.decode(this.bytes()); + } +} +exports.BinaryReader = BinaryReader; + + +/***/ }), + +/***/ 4354: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BinaryWriter = exports.binaryWriteOptions = void 0; +const pb_long_1 = __nccwpck_require__(7777); +const goog_varint_1 = __nccwpck_require__(433); +const assert_1 = __nccwpck_require__(4253); +const defaultsWrite = { + writeUnknownFields: true, + writerFactory: () => new BinaryWriter(), +}; +/** + * Make options for writing binary data form partial options. + */ +function binaryWriteOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite; +} +exports.binaryWriteOptions = binaryWriteOptions; +class BinaryWriter { + constructor(textEncoder) { + /** + * Previous fork states. + */ + this.stack = []; + this.textEncoder = textEncoder !== null && textEncoder !== void 0 ? textEncoder : new TextEncoder(); + this.chunks = []; + this.buf = []; + } + /** + * Return all bytes written and reset this writer. + */ + finish() { + this.chunks.push(new Uint8Array(this.buf)); // flush the buffer + let len = 0; + for (let i = 0; i < this.chunks.length; i++) + len += this.chunks[i].length; + let bytes = new Uint8Array(len); + let offset = 0; + for (let i = 0; i < this.chunks.length; i++) { + bytes.set(this.chunks[i], offset); + offset += this.chunks[i].length; + } + this.chunks = []; + return bytes; + } + /** + * Start a new fork for length-delimited data like a message + * or a packed repeated field. + * + * Must be joined later with `join()`. + */ + fork() { + this.stack.push({ chunks: this.chunks, buf: this.buf }); + this.chunks = []; + this.buf = []; + return this; + } + /** + * Join the last fork. Write its length and bytes, then + * return to the previous state. + */ + join() { + // get chunk of fork + let chunk = this.finish(); + // restore previous state + let prev = this.stack.pop(); + if (!prev) + throw new Error('invalid state, fork stack empty'); + this.chunks = prev.chunks; + this.buf = prev.buf; + // write length of chunk as varint + this.uint32(chunk.byteLength); + return this.raw(chunk); + } + /** + * Writes a tag (field number and wire type). + * + * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`. + * + * Generated code should compute the tag ahead of time and call `uint32()`. + */ + tag(fieldNo, type) { + return this.uint32((fieldNo << 3 | type) >>> 0); + } + /** + * Write a chunk of raw bytes. + */ + raw(chunk) { + if (this.buf.length) { + this.chunks.push(new Uint8Array(this.buf)); + this.buf = []; + } + this.chunks.push(chunk); + return this; + } + /** + * Write a `uint32` value, an unsigned 32 bit varint. + */ + uint32(value) { + assert_1.assertUInt32(value); + // write value as varint 32, inlined for speed + while (value > 0x7f) { + this.buf.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + this.buf.push(value); + return this; + } + /** + * Write a `int32` value, a signed 32 bit varint. + */ + int32(value) { + assert_1.assertInt32(value); + goog_varint_1.varint32write(value, this.buf); + return this; + } + /** + * Write a `bool` value, a variant. + */ + bool(value) { + this.buf.push(value ? 1 : 0); + return this; + } + /** + * Write a `bytes` value, length-delimited arbitrary data. + */ + bytes(value) { + this.uint32(value.byteLength); // write length of chunk as varint + return this.raw(value); + } + /** + * Write a `string` value, length-delimited data converted to UTF-8 text. + */ + string(value) { + let chunk = this.textEncoder.encode(value); + this.uint32(chunk.byteLength); // write length of chunk as varint + return this.raw(chunk); + } + /** + * Write a `float` value, 32-bit floating point number. + */ + float(value) { + assert_1.assertFloat32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setFloat32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `double` value, a 64-bit floating point number. + */ + double(value) { + let chunk = new Uint8Array(8); + new DataView(chunk.buffer).setFloat64(0, value, true); + return this.raw(chunk); + } + /** + * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer. + */ + fixed32(value) { + assert_1.assertUInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setUint32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sfixed32` value, a signed, fixed-length 32-bit integer. + */ + sfixed32(value) { + assert_1.assertInt32(value); + let chunk = new Uint8Array(4); + new DataView(chunk.buffer).setInt32(0, value, true); + return this.raw(chunk); + } + /** + * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint. + */ + sint32(value) { + assert_1.assertInt32(value); + // zigzag encode + value = ((value << 1) ^ (value >> 31)) >>> 0; + goog_varint_1.varint32write(value, this.buf); + return this; + } + /** + * Write a `fixed64` value, a signed, fixed-length 64-bit integer. + */ + sfixed64(value) { + let chunk = new Uint8Array(8); + let view = new DataView(chunk.buffer); + let long = pb_long_1.PbLong.from(value); + view.setInt32(0, long.lo, true); + view.setInt32(4, long.hi, true); + return this.raw(chunk); + } + /** + * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer. + */ + fixed64(value) { + let chunk = new Uint8Array(8); + let view = new DataView(chunk.buffer); + let long = pb_long_1.PbULong.from(value); + view.setInt32(0, long.lo, true); + view.setInt32(4, long.hi, true); + return this.raw(chunk); + } + /** + * Write a `int64` value, a signed 64-bit varint. + */ + int64(value) { + let long = pb_long_1.PbLong.from(value); + goog_varint_1.varint64write(long.lo, long.hi, this.buf); + return this; + } + /** + * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint. + */ + sint64(value) { + let long = pb_long_1.PbLong.from(value), + // zigzag encode + sign = long.hi >> 31, lo = (long.lo << 1) ^ sign, hi = ((long.hi << 1) | (long.lo >>> 31)) ^ sign; + goog_varint_1.varint64write(lo, hi, this.buf); + return this; + } + /** + * Write a `uint64` value, an unsigned 64-bit varint. + */ + uint64(value) { + let long = pb_long_1.PbULong.from(value); + goog_varint_1.varint64write(long.lo, long.hi, this.buf); + return this; + } +} +exports.BinaryWriter = BinaryWriter; + + +/***/ }), + +/***/ 85: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.listEnumNumbers = exports.listEnumNames = exports.listEnumValues = exports.isEnumObject = void 0; +/** + * Is this a lookup object generated by Typescript, for a Typescript enum + * generated by protobuf-ts? + * + * - No `const enum` (enum must not be inlined, we need reverse mapping). + * - No string enum (we need int32 for protobuf). + * - Must have a value for 0 (otherwise, we would need to support custom default values). + */ +function isEnumObject(arg) { + if (typeof arg != 'object' || arg === null) { + return false; + } + if (!arg.hasOwnProperty(0)) { + return false; + } + for (let k of Object.keys(arg)) { + let num = parseInt(k); + if (!Number.isNaN(num)) { + // is there a name for the number? + let nam = arg[num]; + if (nam === undefined) + return false; + // does the name resolve back to the number? + if (arg[nam] !== num) + return false; + } + else { + // is there a number for the name? + let num = arg[k]; + if (num === undefined) + return false; + // is it a string enum? + if (typeof num !== 'number') + return false; + // do we know the number? + if (arg[num] === undefined) + return false; + } + } + return true; +} +exports.isEnumObject = isEnumObject; +/** + * Lists all values of a Typescript enum, as an array of objects with a "name" + * property and a "number" property. + * + * Note that it is possible that a number appears more than once, because it is + * possible to have aliases in an enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumValues(enumObject) { + if (!isEnumObject(enumObject)) + throw new Error("not a typescript enum object"); + let values = []; + for (let [name, number] of Object.entries(enumObject)) + if (typeof number == "number") + values.push({ name, number }); + return values; +} +exports.listEnumValues = listEnumValues; +/** + * Lists the names of a Typescript enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumNames(enumObject) { + return listEnumValues(enumObject).map(val => val.name); +} +exports.listEnumNames = listEnumNames; +/** + * Lists the numbers of a Typescript enum. + * + * Throws if the enum does not adhere to the rules of enums generated by + * protobuf-ts. See `isEnumObject()`. + */ +function listEnumNumbers(enumObject) { + return listEnumValues(enumObject) + .map(val => val.number) + .filter((num, index, arr) => arr.indexOf(num) == index); +} +exports.listEnumNumbers = listEnumNumbers; + + +/***/ }), + +/***/ 433: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// Copyright 2008 Google Inc. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Code generated by the Protocol Buffer compiler is owned by the owner +// of the input file used when generating it. This code is not +// standalone and requires a support library to be linked with it. This +// support library is itself covered by the above license. +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.varint32read = exports.varint32write = exports.int64toString = exports.int64fromString = exports.varint64write = exports.varint64read = void 0; +/** + * Read a 64 bit varint as two JS numbers. + * + * Returns tuple: + * [0]: low bits + * [0]: high bits + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175 + */ +function varint64read() { + let lowBits = 0; + let highBits = 0; + for (let shift = 0; shift < 28; shift += 7) { + let b = this.buf[this.pos++]; + lowBits |= (b & 0x7F) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + let middleByte = this.buf[this.pos++]; + // last four bits of the first 32 bit number + lowBits |= (middleByte & 0x0F) << 28; + // 3 upper bits are part of the next 32 bit number + highBits = (middleByte & 0x70) >> 4; + if ((middleByte & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + for (let shift = 3; shift <= 31; shift += 7) { + let b = this.buf[this.pos++]; + highBits |= (b & 0x7F) << shift; + if ((b & 0x80) == 0) { + this.assertBounds(); + return [lowBits, highBits]; + } + } + throw new Error('invalid varint'); +} +exports.varint64read = varint64read; +/** + * Write a 64 bit varint, given as two JS numbers, to the given bytes array. + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344 + */ +function varint64write(lo, hi, bytes) { + for (let i = 0; i < 28; i = i + 7) { + const shift = lo >>> i; + const hasNext = !((shift >>> 7) == 0 && hi == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xFF; + bytes.push(byte); + if (!hasNext) { + return; + } + } + const splitBits = ((lo >>> 28) & 0x0F) | ((hi & 0x07) << 4); + const hasMoreBits = !((hi >> 3) == 0); + bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xFF); + if (!hasMoreBits) { + return; + } + for (let i = 3; i < 31; i = i + 7) { + const shift = hi >>> i; + const hasNext = !((shift >>> 7) == 0); + const byte = (hasNext ? shift | 0x80 : shift) & 0xFF; + bytes.push(byte); + if (!hasNext) { + return; + } + } + bytes.push((hi >>> 31) & 0x01); +} +exports.varint64write = varint64write; +// constants for binary math +const TWO_PWR_32_DBL = (1 << 16) * (1 << 16); +/** + * Parse decimal string of 64 bit integer value as two JS numbers. + * + * Returns tuple: + * [0]: minus sign? + * [1]: low bits + * [2]: high bits + * + * Copyright 2008 Google Inc. + */ +function int64fromString(dec) { + // Check for minus sign. + let minus = dec[0] == '-'; + if (minus) + dec = dec.slice(1); + // Work 6 decimal digits at a time, acting like we're converting base 1e6 + // digits to binary. This is safe to do with floating point math because + // Number.isSafeInteger(ALL_32_BITS * 1e6) == true. + const base = 1e6; + let lowBits = 0; + let highBits = 0; + function add1e6digit(begin, end) { + // Note: Number('') is 0. + const digit1e6 = Number(dec.slice(begin, end)); + highBits *= base; + lowBits = lowBits * base + digit1e6; + // Carry bits from lowBits to highBits + if (lowBits >= TWO_PWR_32_DBL) { + highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0); + lowBits = lowBits % TWO_PWR_32_DBL; + } + } + add1e6digit(-24, -18); + add1e6digit(-18, -12); + add1e6digit(-12, -6); + add1e6digit(-6); + return [minus, lowBits, highBits]; +} +exports.int64fromString = int64fromString; +/** + * Format 64 bit integer value (as two JS numbers) to decimal string. + * + * Copyright 2008 Google Inc. + */ +function int64toString(bitsLow, bitsHigh) { + // Skip the expensive conversion if the number is small enough to use the + // built-in conversions. + if ((bitsHigh >>> 0) <= 0x1FFFFF) { + return '' + (TWO_PWR_32_DBL * bitsHigh + (bitsLow >>> 0)); + } + // What this code is doing is essentially converting the input number from + // base-2 to base-1e7, which allows us to represent the 64-bit range with + // only 3 (very large) digits. Those digits are then trivial to convert to + // a base-10 string. + // The magic numbers used here are - + // 2^24 = 16777216 = (1,6777216) in base-1e7. + // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7. + // Split 32:32 representation into 16:24:24 representation so our + // intermediate digits don't overflow. + let low = bitsLow & 0xFFFFFF; + let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xFFFFFF; + let high = (bitsHigh >> 16) & 0xFFFF; + // Assemble our three base-1e7 digits, ignoring carries. The maximum + // value in a digit at this step is representable as a 48-bit integer, which + // can be stored in a 64-bit floating point number. + let digitA = low + (mid * 6777216) + (high * 6710656); + let digitB = mid + (high * 8147497); + let digitC = (high * 2); + // Apply carries from A to B and from B to C. + let base = 10000000; + if (digitA >= base) { + digitB += Math.floor(digitA / base); + digitA %= base; + } + if (digitB >= base) { + digitC += Math.floor(digitB / base); + digitB %= base; + } + // Convert base-1e7 digits to base-10, with optional leading zeroes. + function decimalFrom1e7(digit1e7, needLeadingZeros) { + let partial = digit1e7 ? String(digit1e7) : ''; + if (needLeadingZeros) { + return '0000000'.slice(partial.length) + partial; + } + return partial; + } + return decimalFrom1e7(digitC, /*needLeadingZeros=*/ 0) + + decimalFrom1e7(digitB, /*needLeadingZeros=*/ digitC) + + // If the final 1e7 digit didn't need leading zeros, we would have + // returned via the trivial code path at the top. + decimalFrom1e7(digitA, /*needLeadingZeros=*/ 1); +} +exports.int64toString = int64toString; +/** + * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)` + * + * Copyright 2008 Google Inc. All rights reserved. + * + * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144 + */ +function varint32write(value, bytes) { + if (value >= 0) { + // write value as varint 32 + while (value > 0x7f) { + bytes.push((value & 0x7f) | 0x80); + value = value >>> 7; + } + bytes.push(value); + } + else { + for (let i = 0; i < 9; i++) { + bytes.push(value & 127 | 128); + value = value >> 7; + } + bytes.push(1); + } +} +exports.varint32write = varint32write; +/** + * Read an unsigned 32 bit varint. + * + * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220 + */ +function varint32read() { + let b = this.buf[this.pos++]; + let result = b & 0x7F; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 7; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 14; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + b = this.buf[this.pos++]; + result |= (b & 0x7F) << 21; + if ((b & 0x80) == 0) { + this.assertBounds(); + return result; + } + // Extract only last 4 bits + b = this.buf[this.pos++]; + result |= (b & 0x0F) << 28; + for (let readBytes = 5; ((b & 0x80) !== 0) && readBytes < 10; readBytes++) + b = this.buf[this.pos++]; + if ((b & 0x80) != 0) + throw new Error('invalid varint'); + this.assertBounds(); + // Result can have 32 bits, convert it to unsigned + return result >>> 0; +} +exports.varint32read = varint32read; + + +/***/ }), + +/***/ 4061: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +// Public API of the protobuf-ts runtime. +// Note: we do not use `export * from ...` to help tree shakers, +// webpack verbose output hints that this should be useful +Object.defineProperty(exports, "__esModule", ({ value: true })); +// Convenience JSON typings and corresponding type guards +var json_typings_1 = __nccwpck_require__(661); +Object.defineProperty(exports, "typeofJsonValue", ({ enumerable: true, get: function () { return json_typings_1.typeofJsonValue; } })); +Object.defineProperty(exports, "isJsonObject", ({ enumerable: true, get: function () { return json_typings_1.isJsonObject; } })); +// Base 64 encoding +var base64_1 = __nccwpck_require__(196); +Object.defineProperty(exports, "base64decode", ({ enumerable: true, get: function () { return base64_1.base64decode; } })); +Object.defineProperty(exports, "base64encode", ({ enumerable: true, get: function () { return base64_1.base64encode; } })); +// UTF8 encoding +var protobufjs_utf8_1 = __nccwpck_require__(5290); +Object.defineProperty(exports, "utf8read", ({ enumerable: true, get: function () { return protobufjs_utf8_1.utf8read; } })); +// Binary format contracts, options for reading and writing, for example +var binary_format_contract_1 = __nccwpck_require__(4921); +Object.defineProperty(exports, "WireType", ({ enumerable: true, get: function () { return binary_format_contract_1.WireType; } })); +Object.defineProperty(exports, "mergeBinaryOptions", ({ enumerable: true, get: function () { return binary_format_contract_1.mergeBinaryOptions; } })); +Object.defineProperty(exports, "UnknownFieldHandler", ({ enumerable: true, get: function () { return binary_format_contract_1.UnknownFieldHandler; } })); +// Standard IBinaryReader implementation +var binary_reader_1 = __nccwpck_require__(5210); +Object.defineProperty(exports, "BinaryReader", ({ enumerable: true, get: function () { return binary_reader_1.BinaryReader; } })); +Object.defineProperty(exports, "binaryReadOptions", ({ enumerable: true, get: function () { return binary_reader_1.binaryReadOptions; } })); +// Standard IBinaryWriter implementation +var binary_writer_1 = __nccwpck_require__(4354); +Object.defineProperty(exports, "BinaryWriter", ({ enumerable: true, get: function () { return binary_writer_1.BinaryWriter; } })); +Object.defineProperty(exports, "binaryWriteOptions", ({ enumerable: true, get: function () { return binary_writer_1.binaryWriteOptions; } })); +// Int64 and UInt64 implementations required for the binary format +var pb_long_1 = __nccwpck_require__(7777); +Object.defineProperty(exports, "PbLong", ({ enumerable: true, get: function () { return pb_long_1.PbLong; } })); +Object.defineProperty(exports, "PbULong", ({ enumerable: true, get: function () { return pb_long_1.PbULong; } })); +// JSON format contracts, options for reading and writing, for example +var json_format_contract_1 = __nccwpck_require__(8139); +Object.defineProperty(exports, "jsonReadOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonReadOptions; } })); +Object.defineProperty(exports, "jsonWriteOptions", ({ enumerable: true, get: function () { return json_format_contract_1.jsonWriteOptions; } })); +Object.defineProperty(exports, "mergeJsonOptions", ({ enumerable: true, get: function () { return json_format_contract_1.mergeJsonOptions; } })); +// Message type contract +var message_type_contract_1 = __nccwpck_require__(1682); +Object.defineProperty(exports, "MESSAGE_TYPE", ({ enumerable: true, get: function () { return message_type_contract_1.MESSAGE_TYPE; } })); +// Message type implementation via reflection +var message_type_1 = __nccwpck_require__(3664); +Object.defineProperty(exports, "MessageType", ({ enumerable: true, get: function () { return message_type_1.MessageType; } })); +// Reflection info, generated by the plugin, exposed to the user, used by reflection ops +var reflection_info_1 = __nccwpck_require__(1370); +Object.defineProperty(exports, "ScalarType", ({ enumerable: true, get: function () { return reflection_info_1.ScalarType; } })); +Object.defineProperty(exports, "LongType", ({ enumerable: true, get: function () { return reflection_info_1.LongType; } })); +Object.defineProperty(exports, "RepeatType", ({ enumerable: true, get: function () { return reflection_info_1.RepeatType; } })); +Object.defineProperty(exports, "normalizeFieldInfo", ({ enumerable: true, get: function () { return reflection_info_1.normalizeFieldInfo; } })); +Object.defineProperty(exports, "readFieldOptions", ({ enumerable: true, get: function () { return reflection_info_1.readFieldOptions; } })); +Object.defineProperty(exports, "readFieldOption", ({ enumerable: true, get: function () { return reflection_info_1.readFieldOption; } })); +Object.defineProperty(exports, "readMessageOption", ({ enumerable: true, get: function () { return reflection_info_1.readMessageOption; } })); +// Message operations via reflection +var reflection_type_check_1 = __nccwpck_require__(903); +Object.defineProperty(exports, "ReflectionTypeCheck", ({ enumerable: true, get: function () { return reflection_type_check_1.ReflectionTypeCheck; } })); +var reflection_create_1 = __nccwpck_require__(390); +Object.defineProperty(exports, "reflectionCreate", ({ enumerable: true, get: function () { return reflection_create_1.reflectionCreate; } })); +var reflection_scalar_default_1 = __nccwpck_require__(4863); +Object.defineProperty(exports, "reflectionScalarDefault", ({ enumerable: true, get: function () { return reflection_scalar_default_1.reflectionScalarDefault; } })); +var reflection_merge_partial_1 = __nccwpck_require__(7869); +Object.defineProperty(exports, "reflectionMergePartial", ({ enumerable: true, get: function () { return reflection_merge_partial_1.reflectionMergePartial; } })); +var reflection_equals_1 = __nccwpck_require__(9473); +Object.defineProperty(exports, "reflectionEquals", ({ enumerable: true, get: function () { return reflection_equals_1.reflectionEquals; } })); +var reflection_binary_reader_1 = __nccwpck_require__(1593); +Object.defineProperty(exports, "ReflectionBinaryReader", ({ enumerable: true, get: function () { return reflection_binary_reader_1.ReflectionBinaryReader; } })); +var reflection_binary_writer_1 = __nccwpck_require__(7170); +Object.defineProperty(exports, "ReflectionBinaryWriter", ({ enumerable: true, get: function () { return reflection_binary_writer_1.ReflectionBinaryWriter; } })); +var reflection_json_reader_1 = __nccwpck_require__(229); +Object.defineProperty(exports, "ReflectionJsonReader", ({ enumerable: true, get: function () { return reflection_json_reader_1.ReflectionJsonReader; } })); +var reflection_json_writer_1 = __nccwpck_require__(8980); +Object.defineProperty(exports, "ReflectionJsonWriter", ({ enumerable: true, get: function () { return reflection_json_writer_1.ReflectionJsonWriter; } })); +var reflection_contains_message_type_1 = __nccwpck_require__(7317); +Object.defineProperty(exports, "containsMessageType", ({ enumerable: true, get: function () { return reflection_contains_message_type_1.containsMessageType; } })); +// Oneof helpers +var oneof_1 = __nccwpck_require__(8531); +Object.defineProperty(exports, "isOneofGroup", ({ enumerable: true, get: function () { return oneof_1.isOneofGroup; } })); +Object.defineProperty(exports, "setOneofValue", ({ enumerable: true, get: function () { return oneof_1.setOneofValue; } })); +Object.defineProperty(exports, "getOneofValue", ({ enumerable: true, get: function () { return oneof_1.getOneofValue; } })); +Object.defineProperty(exports, "clearOneofValue", ({ enumerable: true, get: function () { return oneof_1.clearOneofValue; } })); +Object.defineProperty(exports, "getSelectedOneofValue", ({ enumerable: true, get: function () { return oneof_1.getSelectedOneofValue; } })); +// Enum object type guard and reflection util, may be interesting to the user. +var enum_object_1 = __nccwpck_require__(85); +Object.defineProperty(exports, "listEnumValues", ({ enumerable: true, get: function () { return enum_object_1.listEnumValues; } })); +Object.defineProperty(exports, "listEnumNames", ({ enumerable: true, get: function () { return enum_object_1.listEnumNames; } })); +Object.defineProperty(exports, "listEnumNumbers", ({ enumerable: true, get: function () { return enum_object_1.listEnumNumbers; } })); +Object.defineProperty(exports, "isEnumObject", ({ enumerable: true, get: function () { return enum_object_1.isEnumObject; } })); +// lowerCamelCase() is exported for plugin, rpc-runtime and other rpc packages +var lower_camel_case_1 = __nccwpck_require__(4772); +Object.defineProperty(exports, "lowerCamelCase", ({ enumerable: true, get: function () { return lower_camel_case_1.lowerCamelCase; } })); +// assertion functions are exported for plugin, may also be useful to user +var assert_1 = __nccwpck_require__(4253); +Object.defineProperty(exports, "assert", ({ enumerable: true, get: function () { return assert_1.assert; } })); +Object.defineProperty(exports, "assertNever", ({ enumerable: true, get: function () { return assert_1.assertNever; } })); +Object.defineProperty(exports, "assertInt32", ({ enumerable: true, get: function () { return assert_1.assertInt32; } })); +Object.defineProperty(exports, "assertUInt32", ({ enumerable: true, get: function () { return assert_1.assertUInt32; } })); +Object.defineProperty(exports, "assertFloat32", ({ enumerable: true, get: function () { return assert_1.assertFloat32; } })); + + +/***/ }), + +/***/ 8139: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.mergeJsonOptions = exports.jsonWriteOptions = exports.jsonReadOptions = void 0; +const defaultsWrite = { + emitDefaultValues: false, + enumAsInteger: false, + useProtoFieldName: false, + prettySpaces: 0, +}, defaultsRead = { + ignoreUnknownFields: false, +}; +/** + * Make options for reading JSON data from partial options. + */ +function jsonReadOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsRead), options) : defaultsRead; +} +exports.jsonReadOptions = jsonReadOptions; +/** + * Make options for writing JSON data from partial options. + */ +function jsonWriteOptions(options) { + return options ? Object.assign(Object.assign({}, defaultsWrite), options) : defaultsWrite; +} +exports.jsonWriteOptions = jsonWriteOptions; +/** + * Merges JSON write or read options. Later values override earlier values. Type registries are merged. + */ +function mergeJsonOptions(a, b) { + var _a, _b; + let c = Object.assign(Object.assign({}, a), b); + c.typeRegistry = [...((_a = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a !== void 0 ? _a : []), ...((_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : [])]; + return c; +} +exports.mergeJsonOptions = mergeJsonOptions; + + +/***/ }), + +/***/ 661: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isJsonObject = exports.typeofJsonValue = void 0; +/** + * Get the type of a JSON value. + * Distinguishes between array, null and object. + */ +function typeofJsonValue(value) { + let t = typeof value; + if (t == "object") { + if (Array.isArray(value)) + return "array"; + if (value === null) + return "null"; + } + return t; +} +exports.typeofJsonValue = typeofJsonValue; +/** + * Is this a JSON object (instead of an array or null)? + */ +function isJsonObject(value) { + return value !== null && typeof value == "object" && !Array.isArray(value); +} +exports.isJsonObject = isJsonObject; + + +/***/ }), + +/***/ 4772: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.lowerCamelCase = void 0; +/** + * Converts snake_case to lowerCamelCase. + * + * Should behave like protoc: + * https://github.com/protocolbuffers/protobuf/blob/e8ae137c96444ea313485ed1118c5e43b2099cf1/src/google/protobuf/compiler/java/java_helpers.cc#L118 + */ +function lowerCamelCase(snakeCase) { + let capNext = false; + const sb = []; + for (let i = 0; i < snakeCase.length; i++) { + let next = snakeCase.charAt(i); + if (next == '_') { + capNext = true; + } + else if (/\d/.test(next)) { + sb.push(next); + capNext = true; + } + else if (capNext) { + sb.push(next.toUpperCase()); + capNext = false; + } + else if (i == 0) { + sb.push(next.toLowerCase()); + } + else { + sb.push(next); + } + } + return sb.join(''); +} +exports.lowerCamelCase = lowerCamelCase; + + +/***/ }), + +/***/ 1682: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MESSAGE_TYPE = void 0; +/** + * The symbol used as a key on message objects to store the message type. + * + * Note that this is an experimental feature - it is here to stay, but + * implementation details may change without notice. + */ +exports.MESSAGE_TYPE = Symbol.for("protobuf-ts/message-type"); + + +/***/ }), + +/***/ 3664: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.MessageType = void 0; +const message_type_contract_1 = __nccwpck_require__(1682); +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_type_check_1 = __nccwpck_require__(903); +const reflection_json_reader_1 = __nccwpck_require__(229); +const reflection_json_writer_1 = __nccwpck_require__(8980); +const reflection_binary_reader_1 = __nccwpck_require__(1593); +const reflection_binary_writer_1 = __nccwpck_require__(7170); +const reflection_create_1 = __nccwpck_require__(390); +const reflection_merge_partial_1 = __nccwpck_require__(7869); +const json_typings_1 = __nccwpck_require__(661); +const json_format_contract_1 = __nccwpck_require__(8139); +const reflection_equals_1 = __nccwpck_require__(9473); +const binary_writer_1 = __nccwpck_require__(4354); +const binary_reader_1 = __nccwpck_require__(5210); +const baseDescriptors = Object.getOwnPropertyDescriptors(Object.getPrototypeOf({})); +/** + * This standard message type provides reflection-based + * operations to work with a message. + */ +class MessageType { + constructor(name, fields, options) { + this.defaultCheckDepth = 16; + this.typeName = name; + this.fields = fields.map(reflection_info_1.normalizeFieldInfo); + this.options = options !== null && options !== void 0 ? options : {}; + this.messagePrototype = Object.create(null, Object.assign(Object.assign({}, baseDescriptors), { [message_type_contract_1.MESSAGE_TYPE]: { value: this } })); + this.refTypeCheck = new reflection_type_check_1.ReflectionTypeCheck(this); + this.refJsonReader = new reflection_json_reader_1.ReflectionJsonReader(this); + this.refJsonWriter = new reflection_json_writer_1.ReflectionJsonWriter(this); + this.refBinReader = new reflection_binary_reader_1.ReflectionBinaryReader(this); + this.refBinWriter = new reflection_binary_writer_1.ReflectionBinaryWriter(this); + } + create(value) { + let message = reflection_create_1.reflectionCreate(this); + if (value !== undefined) { + reflection_merge_partial_1.reflectionMergePartial(this, message, value); + } + return message; + } + /** + * Clone the message. + * + * Unknown fields are discarded. + */ + clone(message) { + let copy = this.create(); + reflection_merge_partial_1.reflectionMergePartial(this, copy, message); + return copy; + } + /** + * Determines whether two message of the same type have the same field values. + * Checks for deep equality, traversing repeated fields, oneof groups, maps + * and messages recursively. + * Will also return true if both messages are `undefined`. + */ + equals(a, b) { + return reflection_equals_1.reflectionEquals(this, a, b); + } + /** + * Is the given value assignable to our message type + * and contains no [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)? + */ + is(arg, depth = this.defaultCheckDepth) { + return this.refTypeCheck.is(arg, depth, false); + } + /** + * Is the given value assignable to our message type, + * regardless of [excess properties](https://www.typescriptlang.org/docs/handbook/interfaces.html#excess-property-checks)? + */ + isAssignable(arg, depth = this.defaultCheckDepth) { + return this.refTypeCheck.is(arg, depth, true); + } + /** + * Copy partial data into the target message. + */ + mergePartial(target, source) { + reflection_merge_partial_1.reflectionMergePartial(this, target, source); + } + /** + * Create a new message from binary format. + */ + fromBinary(data, options) { + let opt = binary_reader_1.binaryReadOptions(options); + return this.internalBinaryRead(opt.readerFactory(data), data.byteLength, opt); + } + /** + * Read a new message from a JSON value. + */ + fromJson(json, options) { + return this.internalJsonRead(json, json_format_contract_1.jsonReadOptions(options)); + } + /** + * Read a new message from a JSON string. + * This is equivalent to `T.fromJson(JSON.parse(json))`. + */ + fromJsonString(json, options) { + let value = JSON.parse(json); + return this.fromJson(value, options); + } + /** + * Write the message to canonical JSON value. + */ + toJson(message, options) { + return this.internalJsonWrite(message, json_format_contract_1.jsonWriteOptions(options)); + } + /** + * Convert the message to canonical JSON string. + * This is equivalent to `JSON.stringify(T.toJson(t))` + */ + toJsonString(message, options) { + var _a; + let value = this.toJson(message, options); + return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0); + } + /** + * Write the message to binary format. + */ + toBinary(message, options) { + let opt = binary_writer_1.binaryWriteOptions(options); + return this.internalBinaryWrite(message, opt.writerFactory(), opt).finish(); + } + /** + * This is an internal method. If you just want to read a message from + * JSON, use `fromJson()` or `fromJsonString()`. + * + * Reads JSON value and merges the fields into the target + * according to protobuf rules. If the target is omitted, + * a new instance is created first. + */ + internalJsonRead(json, options, target) { + if (json !== null && typeof json == "object" && !Array.isArray(json)) { + let message = target !== null && target !== void 0 ? target : this.create(); + this.refJsonReader.read(json, message, options); + return message; + } + throw new Error(`Unable to parse message ${this.typeName} from JSON ${json_typings_1.typeofJsonValue(json)}.`); + } + /** + * This is an internal method. If you just want to write a message + * to JSON, use `toJson()` or `toJsonString(). + * + * Writes JSON value and returns it. + */ + internalJsonWrite(message, options) { + return this.refJsonWriter.write(message, options); + } + /** + * This is an internal method. If you just want to write a message + * in binary format, use `toBinary()`. + * + * Serializes the message in binary format and appends it to the given + * writer. Returns passed writer. + */ + internalBinaryWrite(message, writer, options) { + this.refBinWriter.write(message, writer, options); + return writer; + } + /** + * This is an internal method. If you just want to read a message from + * binary data, use `fromBinary()`. + * + * Reads data from binary format and merges the fields into + * the target according to protobuf rules. If the target is + * omitted, a new instance is created first. + */ + internalBinaryRead(reader, length, options, target) { + let message = target !== null && target !== void 0 ? target : this.create(); + this.refBinReader.read(reader, message, options, length); + return message; + } +} +exports.MessageType = MessageType; + + +/***/ }), + +/***/ 8531: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getSelectedOneofValue = exports.clearOneofValue = exports.setUnknownOneofValue = exports.setOneofValue = exports.getOneofValue = exports.isOneofGroup = void 0; +/** + * Is the given value a valid oneof group? + * + * We represent protobuf `oneof` as algebraic data types (ADT) in generated + * code. But when working with messages of unknown type, the ADT does not + * help us. + * + * This type guard checks if the given object adheres to the ADT rules, which + * are as follows: + * + * 1) Must be an object. + * + * 2) Must have a "oneofKind" discriminator property. + * + * 3) If "oneofKind" is `undefined`, no member field is selected. The object + * must not have any other properties. + * + * 4) If "oneofKind" is a `string`, the member field with this name is + * selected. + * + * 5) If a member field is selected, the object must have a second property + * with this name. The property must not be `undefined`. + * + * 6) No extra properties are allowed. The object has either one property + * (no selection) or two properties (selection). + * + */ +function isOneofGroup(any) { + if (typeof any != 'object' || any === null || !any.hasOwnProperty('oneofKind')) { + return false; + } + switch (typeof any.oneofKind) { + case "string": + if (any[any.oneofKind] === undefined) + return false; + return Object.keys(any).length == 2; + case "undefined": + return Object.keys(any).length == 1; + default: + return false; + } +} +exports.isOneofGroup = isOneofGroup; +/** + * Returns the value of the given field in a oneof group. + */ +function getOneofValue(oneof, kind) { + return oneof[kind]; +} +exports.getOneofValue = getOneofValue; +function setOneofValue(oneof, kind, value) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = kind; + if (value !== undefined) { + oneof[kind] = value; + } +} +exports.setOneofValue = setOneofValue; +function setUnknownOneofValue(oneof, kind, value) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = kind; + if (value !== undefined && kind !== undefined) { + oneof[kind] = value; + } +} +exports.setUnknownOneofValue = setUnknownOneofValue; +/** + * Removes the selected field in a oneof group. + * + * Note that the recommended way to modify a oneof group is to set + * a new object: + * + * ```ts + * message.result = { oneofKind: undefined }; + * ``` + */ +function clearOneofValue(oneof) { + if (oneof.oneofKind !== undefined) { + delete oneof[oneof.oneofKind]; + } + oneof.oneofKind = undefined; +} +exports.clearOneofValue = clearOneofValue; +/** + * Returns the selected value of the given oneof group. + * + * Not that the recommended way to access a oneof group is to check + * the "oneofKind" property and let TypeScript narrow down the union + * type for you: + * + * ```ts + * if (message.result.oneofKind === "error") { + * message.result.error; // string + * } + * ``` + * + * In the rare case you just need the value, and do not care about + * which protobuf field is selected, you can use this function + * for convenience. + */ +function getSelectedOneofValue(oneof) { + if (oneof.oneofKind === undefined) { + return undefined; + } + return oneof[oneof.oneofKind]; +} +exports.getSelectedOneofValue = getSelectedOneofValue; + + +/***/ }), + +/***/ 7777: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.PbLong = exports.PbULong = exports.detectBi = void 0; +const goog_varint_1 = __nccwpck_require__(433); +let BI; +function detectBi() { + const dv = new DataView(new ArrayBuffer(8)); + const ok = globalThis.BigInt !== undefined + && typeof dv.getBigInt64 === "function" + && typeof dv.getBigUint64 === "function" + && typeof dv.setBigInt64 === "function" + && typeof dv.setBigUint64 === "function"; + BI = ok ? { + MIN: BigInt("-9223372036854775808"), + MAX: BigInt("9223372036854775807"), + UMIN: BigInt("0"), + UMAX: BigInt("18446744073709551615"), + C: BigInt, + V: dv, + } : undefined; +} +exports.detectBi = detectBi; +detectBi(); +function assertBi(bi) { + if (!bi) + throw new Error("BigInt unavailable, see https://github.com/timostamm/protobuf-ts/blob/v1.0.8/MANUAL.md#bigint-support"); +} +// used to validate from(string) input (when bigint is unavailable) +const RE_DECIMAL_STR = /^-?[0-9]+$/; +// constants for binary math +const TWO_PWR_32_DBL = 0x100000000; +const HALF_2_PWR_32 = 0x080000000; +// base class for PbLong and PbULong provides shared code +class SharedPbLong { + /** + * Create a new instance with the given bits. + */ + constructor(lo, hi) { + this.lo = lo | 0; + this.hi = hi | 0; + } + /** + * Is this instance equal to 0? + */ + isZero() { + return this.lo == 0 && this.hi == 0; + } + /** + * Convert to a native number. + */ + toNumber() { + let result = this.hi * TWO_PWR_32_DBL + (this.lo >>> 0); + if (!Number.isSafeInteger(result)) + throw new Error("cannot convert to safe number"); + return result; + } +} +/** + * 64-bit unsigned integer as two 32-bit values. + * Converts between `string`, `number` and `bigint` representations. + */ +class PbULong extends SharedPbLong { + /** + * Create instance from a `string`, `number` or `bigint`. + */ + static from(value) { + if (BI) + // noinspection FallThroughInSwitchStatementJS + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + if (value == "") + throw new Error('string is no integer'); + value = BI.C(value); + case "number": + if (value === 0) + return this.ZERO; + value = BI.C(value); + case "bigint": + if (!value) + return this.ZERO; + if (value < BI.UMIN) + throw new Error('signed value for ulong'); + if (value > BI.UMAX) + throw new Error('ulong too large'); + BI.V.setBigUint64(0, value, true); + return new PbULong(BI.V.getInt32(0, true), BI.V.getInt32(4, true)); + } + else + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + value = value.trim(); + if (!RE_DECIMAL_STR.test(value)) + throw new Error('string is no integer'); + let [minus, lo, hi] = goog_varint_1.int64fromString(value); + if (minus) + throw new Error('signed value for ulong'); + return new PbULong(lo, hi); + case "number": + if (value == 0) + return this.ZERO; + if (!Number.isSafeInteger(value)) + throw new Error('number is no integer'); + if (value < 0) + throw new Error('signed value for ulong'); + return new PbULong(value, value / TWO_PWR_32_DBL); + } + throw new Error('unknown value ' + typeof value); + } + /** + * Convert to decimal string. + */ + toString() { + return BI ? this.toBigInt().toString() : goog_varint_1.int64toString(this.lo, this.hi); + } + /** + * Convert to native bigint. + */ + toBigInt() { + assertBi(BI); + BI.V.setInt32(0, this.lo, true); + BI.V.setInt32(4, this.hi, true); + return BI.V.getBigUint64(0, true); + } +} +exports.PbULong = PbULong; +/** + * ulong 0 singleton. + */ +PbULong.ZERO = new PbULong(0, 0); +/** + * 64-bit signed integer as two 32-bit values. + * Converts between `string`, `number` and `bigint` representations. + */ +class PbLong extends SharedPbLong { + /** + * Create instance from a `string`, `number` or `bigint`. + */ + static from(value) { + if (BI) + // noinspection FallThroughInSwitchStatementJS + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + if (value == "") + throw new Error('string is no integer'); + value = BI.C(value); + case "number": + if (value === 0) + return this.ZERO; + value = BI.C(value); + case "bigint": + if (!value) + return this.ZERO; + if (value < BI.MIN) + throw new Error('signed long too small'); + if (value > BI.MAX) + throw new Error('signed long too large'); + BI.V.setBigInt64(0, value, true); + return new PbLong(BI.V.getInt32(0, true), BI.V.getInt32(4, true)); + } + else + switch (typeof value) { + case "string": + if (value == "0") + return this.ZERO; + value = value.trim(); + if (!RE_DECIMAL_STR.test(value)) + throw new Error('string is no integer'); + let [minus, lo, hi] = goog_varint_1.int64fromString(value); + if (minus) { + if (hi > HALF_2_PWR_32 || (hi == HALF_2_PWR_32 && lo != 0)) + throw new Error('signed long too small'); + } + else if (hi >= HALF_2_PWR_32) + throw new Error('signed long too large'); + let pbl = new PbLong(lo, hi); + return minus ? pbl.negate() : pbl; + case "number": + if (value == 0) + return this.ZERO; + if (!Number.isSafeInteger(value)) + throw new Error('number is no integer'); + return value > 0 + ? new PbLong(value, value / TWO_PWR_32_DBL) + : new PbLong(-value, -value / TWO_PWR_32_DBL).negate(); + } + throw new Error('unknown value ' + typeof value); + } + /** + * Do we have a minus sign? + */ + isNegative() { + return (this.hi & HALF_2_PWR_32) !== 0; + } + /** + * Negate two's complement. + * Invert all the bits and add one to the result. + */ + negate() { + let hi = ~this.hi, lo = this.lo; + if (lo) + lo = ~lo + 1; + else + hi += 1; + return new PbLong(lo, hi); + } + /** + * Convert to decimal string. + */ + toString() { + if (BI) + return this.toBigInt().toString(); + if (this.isNegative()) { + let n = this.negate(); + return '-' + goog_varint_1.int64toString(n.lo, n.hi); + } + return goog_varint_1.int64toString(this.lo, this.hi); + } + /** + * Convert to native bigint. + */ + toBigInt() { + assertBi(BI); + BI.V.setInt32(0, this.lo, true); + BI.V.setInt32(4, this.hi, true); + return BI.V.getBigInt64(0, true); + } +} +exports.PbLong = PbLong; +/** + * long 0 singleton. + */ +PbLong.ZERO = new PbLong(0, 0); + + +/***/ }), + +/***/ 5290: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// Copyright (c) 2016, Daniel Wirtz All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// * Neither the name of its author, nor the names of its contributors +// may be used to endorse or promote products derived from this software +// without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.utf8read = void 0; +const fromCharCodes = (chunk) => String.fromCharCode.apply(String, chunk); +/** + * @deprecated This function will no longer be exported with the next major + * release, since protobuf-ts has switch to TextDecoder API. If you need this + * function, please migrate to @protobufjs/utf8. For context, see + * https://github.com/timostamm/protobuf-ts/issues/184 + * + * Reads UTF8 bytes as a string. + * + * See [protobufjs / utf8](https://github.com/protobufjs/protobuf.js/blob/9893e35b854621cce64af4bf6be2cff4fb892796/lib/utf8/index.js#L40) + * + * Copyright (c) 2016, Daniel Wirtz + */ +function utf8read(bytes) { + if (bytes.length < 1) + return ""; + let pos = 0, // position in bytes + parts = [], chunk = [], i = 0, // char offset + t; // temporary + let len = bytes.length; + while (pos < len) { + t = bytes[pos++]; + if (t < 128) + chunk[i++] = t; + else if (t > 191 && t < 224) + chunk[i++] = (t & 31) << 6 | bytes[pos++] & 63; + else if (t > 239 && t < 365) { + t = ((t & 7) << 18 | (bytes[pos++] & 63) << 12 | (bytes[pos++] & 63) << 6 | bytes[pos++] & 63) - 0x10000; + chunk[i++] = 0xD800 + (t >> 10); + chunk[i++] = 0xDC00 + (t & 1023); + } + else + chunk[i++] = (t & 15) << 12 | (bytes[pos++] & 63) << 6 | bytes[pos++] & 63; + if (i > 8191) { + parts.push(fromCharCodes(chunk)); + i = 0; + } + } + if (parts.length) { + if (i) + parts.push(fromCharCodes(chunk.slice(0, i))); + return parts.join(""); + } + return fromCharCodes(chunk.slice(0, i)); +} +exports.utf8read = utf8read; + + +/***/ }), + +/***/ 1593: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionBinaryReader = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_long_convert_1 = __nccwpck_require__(4612); +const reflection_scalar_default_1 = __nccwpck_require__(4863); +/** + * Reads proto3 messages in binary format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/encoding + */ +class ReflectionBinaryReader { + constructor(info) { + this.info = info; + } + prepare() { + var _a; + if (!this.fieldNoToField) { + const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : []; + this.fieldNoToField = new Map(fieldsInput.map(field => [field.no, field])); + } + } + /** + * Reads a message from binary format into the target message. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ + read(reader, message, options, length) { + this.prepare(); + const end = length === undefined ? reader.len : reader.pos + length; + while (reader.pos < end) { + // read the tag and find the field + const [fieldNo, wireType] = reader.tag(), field = this.fieldNoToField.get(fieldNo); + if (!field) { + let u = options.readUnknownField; + if (u == "throw") + throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.info.typeName}`); + let d = reader.skip(wireType); + if (u !== false) + (u === true ? binary_format_contract_1.UnknownFieldHandler.onRead : u)(this.info.typeName, message, fieldNo, wireType, d); + continue; + } + // target object for the field we are reading + let target = message, repeated = field.repeat, localName = field.localName; + // if field is member of oneof ADT, use ADT as target + if (field.oneof) { + target = target[field.oneof]; + // if other oneof member selected, set new ADT + if (target.oneofKind !== localName) + target = message[field.oneof] = { + oneofKind: localName + }; + } + // we have handled oneof above, we just have read the value into `target[localName]` + switch (field.kind) { + case "scalar": + case "enum": + let T = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + let L = field.kind == "scalar" ? field.L : undefined; + if (repeated) { + let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values + if (wireType == binary_format_contract_1.WireType.LengthDelimited && T != reflection_info_1.ScalarType.STRING && T != reflection_info_1.ScalarType.BYTES) { + let e = reader.uint32() + reader.pos; + while (reader.pos < e) + arr.push(this.scalar(reader, T, L)); + } + else + arr.push(this.scalar(reader, T, L)); + } + else + target[localName] = this.scalar(reader, T, L); + break; + case "message": + if (repeated) { + let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values + let msg = field.T().internalBinaryRead(reader, reader.uint32(), options); + arr.push(msg); + } + else + target[localName] = field.T().internalBinaryRead(reader, reader.uint32(), options, target[localName]); + break; + case "map": + let [mapKey, mapVal] = this.mapEntry(field, reader, options); + // safe to assume presence of map object, oneof cannot contain repeated values + target[localName][mapKey] = mapVal; + break; + } + } + } + /** + * Read a map field, expecting key field = 1, value field = 2 + */ + mapEntry(field, reader, options) { + let length = reader.uint32(); + let end = reader.pos + length; + let key = undefined; // javascript only allows number or string for object properties + let val = undefined; + while (reader.pos < end) { + let [fieldNo, wireType] = reader.tag(); + switch (fieldNo) { + case 1: + if (field.K == reflection_info_1.ScalarType.BOOL) + key = reader.bool().toString(); + else + // long types are read as string, number types are okay as number + key = this.scalar(reader, field.K, reflection_info_1.LongType.STRING); + break; + case 2: + switch (field.V.kind) { + case "scalar": + val = this.scalar(reader, field.V.T, field.V.L); + break; + case "enum": + val = reader.int32(); + break; + case "message": + val = field.V.T().internalBinaryRead(reader, reader.uint32(), options); + break; + } + break; + default: + throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) in map entry for ${this.info.typeName}#${field.name}`); + } + } + if (key === undefined) { + let keyRaw = reflection_scalar_default_1.reflectionScalarDefault(field.K); + key = field.K == reflection_info_1.ScalarType.BOOL ? keyRaw.toString() : keyRaw; + } + if (val === undefined) + switch (field.V.kind) { + case "scalar": + val = reflection_scalar_default_1.reflectionScalarDefault(field.V.T, field.V.L); + break; + case "enum": + val = 0; + break; + case "message": + val = field.V.T().create(); + break; + } + return [key, val]; + } + scalar(reader, type, longType) { + switch (type) { + case reflection_info_1.ScalarType.INT32: + return reader.int32(); + case reflection_info_1.ScalarType.STRING: + return reader.string(); + case reflection_info_1.ScalarType.BOOL: + return reader.bool(); + case reflection_info_1.ScalarType.DOUBLE: + return reader.double(); + case reflection_info_1.ScalarType.FLOAT: + return reader.float(); + case reflection_info_1.ScalarType.INT64: + return reflection_long_convert_1.reflectionLongConvert(reader.int64(), longType); + case reflection_info_1.ScalarType.UINT64: + return reflection_long_convert_1.reflectionLongConvert(reader.uint64(), longType); + case reflection_info_1.ScalarType.FIXED64: + return reflection_long_convert_1.reflectionLongConvert(reader.fixed64(), longType); + case reflection_info_1.ScalarType.FIXED32: + return reader.fixed32(); + case reflection_info_1.ScalarType.BYTES: + return reader.bytes(); + case reflection_info_1.ScalarType.UINT32: + return reader.uint32(); + case reflection_info_1.ScalarType.SFIXED32: + return reader.sfixed32(); + case reflection_info_1.ScalarType.SFIXED64: + return reflection_long_convert_1.reflectionLongConvert(reader.sfixed64(), longType); + case reflection_info_1.ScalarType.SINT32: + return reader.sint32(); + case reflection_info_1.ScalarType.SINT64: + return reflection_long_convert_1.reflectionLongConvert(reader.sint64(), longType); + } + } +} +exports.ReflectionBinaryReader = ReflectionBinaryReader; + + +/***/ }), + +/***/ 7170: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionBinaryWriter = void 0; +const binary_format_contract_1 = __nccwpck_require__(4921); +const reflection_info_1 = __nccwpck_require__(1370); +const assert_1 = __nccwpck_require__(4253); +const pb_long_1 = __nccwpck_require__(7777); +/** + * Writes proto3 messages in binary format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/encoding + */ +class ReflectionBinaryWriter { + constructor(info) { + this.info = info; + } + prepare() { + if (!this.fields) { + const fieldsInput = this.info.fields ? this.info.fields.concat() : []; + this.fields = fieldsInput.sort((a, b) => a.no - b.no); + } + } + /** + * Writes the message to binary format. + */ + write(message, writer, options) { + this.prepare(); + for (const field of this.fields) { + let value, // this will be our field value, whether it is member of a oneof or not + emitDefault, // whether we emit the default value (only true for oneof members) + repeated = field.repeat, localName = field.localName; + // handle oneof ADT + if (field.oneof) { + const group = message[field.oneof]; + if (group.oneofKind !== localName) + continue; // if field is not selected, skip + value = group[localName]; + emitDefault = true; + } + else { + value = message[localName]; + emitDefault = false; + } + // we have handled oneof above. we just have to honor `emitDefault`. + switch (field.kind) { + case "scalar": + case "enum": + let T = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + if (repeated) { + assert_1.assert(Array.isArray(value)); + if (repeated == reflection_info_1.RepeatType.PACKED) + this.packed(writer, T, field.no, value); + else + for (const item of value) + this.scalar(writer, T, field.no, item, true); + } + else if (value === undefined) + assert_1.assert(field.opt); + else + this.scalar(writer, T, field.no, value, emitDefault || field.opt); + break; + case "message": + if (repeated) { + assert_1.assert(Array.isArray(value)); + for (const item of value) + this.message(writer, options, field.T(), field.no, item); + } + else { + this.message(writer, options, field.T(), field.no, value); + } + break; + case "map": + assert_1.assert(typeof value == 'object' && value !== null); + for (const [key, val] of Object.entries(value)) + this.mapEntry(writer, options, field, key, val); + break; + } + } + let u = options.writeUnknownFields; + if (u !== false) + (u === true ? binary_format_contract_1.UnknownFieldHandler.onWrite : u)(this.info.typeName, message, writer); + } + mapEntry(writer, options, field, key, value) { + writer.tag(field.no, binary_format_contract_1.WireType.LengthDelimited); + writer.fork(); + // javascript only allows number or string for object properties + // we convert from our representation to the protobuf type + let keyValue = key; + switch (field.K) { + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.UINT32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + keyValue = Number.parseInt(key); + break; + case reflection_info_1.ScalarType.BOOL: + assert_1.assert(key == 'true' || key == 'false'); + keyValue = key == 'true'; + break; + } + // write key, expecting key field number = 1 + this.scalar(writer, field.K, 1, keyValue, true); + // write value, expecting value field number = 2 + switch (field.V.kind) { + case 'scalar': + this.scalar(writer, field.V.T, 2, value, true); + break; + case 'enum': + this.scalar(writer, reflection_info_1.ScalarType.INT32, 2, value, true); + break; + case 'message': + this.message(writer, options, field.V.T(), 2, value); + break; + } + writer.join(); + } + message(writer, options, handler, fieldNo, value) { + if (value === undefined) + return; + handler.internalBinaryWrite(value, writer.tag(fieldNo, binary_format_contract_1.WireType.LengthDelimited).fork(), options); + writer.join(); + } + /** + * Write a single scalar value. + */ + scalar(writer, type, fieldNo, value, emitDefault) { + let [wireType, method, isDefault] = this.scalarInfo(type, value); + if (!isDefault || emitDefault) { + writer.tag(fieldNo, wireType); + writer[method](value); + } + } + /** + * Write an array of scalar values in packed format. + */ + packed(writer, type, fieldNo, value) { + if (!value.length) + return; + assert_1.assert(type !== reflection_info_1.ScalarType.BYTES && type !== reflection_info_1.ScalarType.STRING); + // write tag + writer.tag(fieldNo, binary_format_contract_1.WireType.LengthDelimited); + // begin length-delimited + writer.fork(); + // write values without tags + let [, method,] = this.scalarInfo(type); + for (let i = 0; i < value.length; i++) + writer[method](value[i]); + // end length delimited + writer.join(); + } + /** + * Get information for writing a scalar value. + * + * Returns tuple: + * [0]: appropriate WireType + * [1]: name of the appropriate method of IBinaryWriter + * [2]: whether the given value is a default value + * + * If argument `value` is omitted, [2] is always false. + */ + scalarInfo(type, value) { + let t = binary_format_contract_1.WireType.Varint; + let m; + let i = value === undefined; + let d = value === 0; + switch (type) { + case reflection_info_1.ScalarType.INT32: + m = "int32"; + break; + case reflection_info_1.ScalarType.STRING: + d = i || !value.length; + t = binary_format_contract_1.WireType.LengthDelimited; + m = "string"; + break; + case reflection_info_1.ScalarType.BOOL: + d = value === false; + m = "bool"; + break; + case reflection_info_1.ScalarType.UINT32: + m = "uint32"; + break; + case reflection_info_1.ScalarType.DOUBLE: + t = binary_format_contract_1.WireType.Bit64; + m = "double"; + break; + case reflection_info_1.ScalarType.FLOAT: + t = binary_format_contract_1.WireType.Bit32; + m = "float"; + break; + case reflection_info_1.ScalarType.INT64: + d = i || pb_long_1.PbLong.from(value).isZero(); + m = "int64"; + break; + case reflection_info_1.ScalarType.UINT64: + d = i || pb_long_1.PbULong.from(value).isZero(); + m = "uint64"; + break; + case reflection_info_1.ScalarType.FIXED64: + d = i || pb_long_1.PbULong.from(value).isZero(); + t = binary_format_contract_1.WireType.Bit64; + m = "fixed64"; + break; + case reflection_info_1.ScalarType.BYTES: + d = i || !value.byteLength; + t = binary_format_contract_1.WireType.LengthDelimited; + m = "bytes"; + break; + case reflection_info_1.ScalarType.FIXED32: + t = binary_format_contract_1.WireType.Bit32; + m = "fixed32"; + break; + case reflection_info_1.ScalarType.SFIXED32: + t = binary_format_contract_1.WireType.Bit32; + m = "sfixed32"; + break; + case reflection_info_1.ScalarType.SFIXED64: + d = i || pb_long_1.PbLong.from(value).isZero(); + t = binary_format_contract_1.WireType.Bit64; + m = "sfixed64"; + break; + case reflection_info_1.ScalarType.SINT32: + m = "sint32"; + break; + case reflection_info_1.ScalarType.SINT64: + d = i || pb_long_1.PbLong.from(value).isZero(); + m = "sint64"; + break; + } + return [t, m, i || d]; + } +} +exports.ReflectionBinaryWriter = ReflectionBinaryWriter; + + +/***/ }), + +/***/ 7317: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.containsMessageType = void 0; +const message_type_contract_1 = __nccwpck_require__(1682); +/** + * Check if the provided object is a proto message. + * + * Note that this is an experimental feature - it is here to stay, but + * implementation details may change without notice. + */ +function containsMessageType(msg) { + return msg[message_type_contract_1.MESSAGE_TYPE] != null; +} +exports.containsMessageType = containsMessageType; + + +/***/ }), + +/***/ 390: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionCreate = void 0; +const reflection_scalar_default_1 = __nccwpck_require__(4863); +const message_type_contract_1 = __nccwpck_require__(1682); +/** + * Creates an instance of the generic message, using the field + * information. + */ +function reflectionCreate(type) { + /** + * This ternary can be removed in the next major version. + * The `Object.create()` code path utilizes a new `messagePrototype` + * property on the `IMessageType` which has this same `MESSAGE_TYPE` + * non-enumerable property on it. Doing it this way means that we only + * pay the cost of `Object.defineProperty()` once per `IMessageType` + * class of once per "instance". The falsy code path is only provided + * for backwards compatibility in cases where the runtime library is + * updated without also updating the generated code. + */ + const msg = type.messagePrototype + ? Object.create(type.messagePrototype) + : Object.defineProperty({}, message_type_contract_1.MESSAGE_TYPE, { value: type }); + for (let field of type.fields) { + let name = field.localName; + if (field.opt) + continue; + if (field.oneof) + msg[field.oneof] = { oneofKind: undefined }; + else if (field.repeat) + msg[name] = []; + else + switch (field.kind) { + case "scalar": + msg[name] = reflection_scalar_default_1.reflectionScalarDefault(field.T, field.L); + break; + case "enum": + // we require 0 to be default value for all enums + msg[name] = 0; + break; + case "map": + msg[name] = {}; + break; + } + } + return msg; +} +exports.reflectionCreate = reflectionCreate; + + +/***/ }), + +/***/ 9473: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionEquals = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +/** + * Determines whether two message of the same type have the same field values. + * Checks for deep equality, traversing repeated fields, oneof groups, maps + * and messages recursively. + * Will also return true if both messages are `undefined`. + */ +function reflectionEquals(info, a, b) { + if (a === b) + return true; + if (!a || !b) + return false; + for (let field of info.fields) { + let localName = field.localName; + let val_a = field.oneof ? a[field.oneof][localName] : a[localName]; + let val_b = field.oneof ? b[field.oneof][localName] : b[localName]; + switch (field.kind) { + case "enum": + case "scalar": + let t = field.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.T; + if (!(field.repeat + ? repeatedPrimitiveEq(t, val_a, val_b) + : primitiveEq(t, val_a, val_b))) + return false; + break; + case "map": + if (!(field.V.kind == "message" + ? repeatedMsgEq(field.V.T(), objectValues(val_a), objectValues(val_b)) + : repeatedPrimitiveEq(field.V.kind == "enum" ? reflection_info_1.ScalarType.INT32 : field.V.T, objectValues(val_a), objectValues(val_b)))) + return false; + break; + case "message": + let T = field.T(); + if (!(field.repeat + ? repeatedMsgEq(T, val_a, val_b) + : T.equals(val_a, val_b))) + return false; + break; + } + } + return true; +} +exports.reflectionEquals = reflectionEquals; +const objectValues = Object.values; +function primitiveEq(type, a, b) { + if (a === b) + return true; + if (type !== reflection_info_1.ScalarType.BYTES) + return false; + let ba = a; + let bb = b; + if (ba.length !== bb.length) + return false; + for (let i = 0; i < ba.length; i++) + if (ba[i] != bb[i]) + return false; + return true; +} +function repeatedPrimitiveEq(type, a, b) { + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; i++) + if (!primitiveEq(type, a[i], b[i])) + return false; + return true; +} +function repeatedMsgEq(type, a, b) { + if (a.length !== b.length) + return false; + for (let i = 0; i < a.length; i++) + if (!type.equals(a[i], b[i])) + return false; + return true; +} + + +/***/ }), + +/***/ 1370: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.readMessageOption = exports.readFieldOption = exports.readFieldOptions = exports.normalizeFieldInfo = exports.RepeatType = exports.LongType = exports.ScalarType = void 0; +const lower_camel_case_1 = __nccwpck_require__(4772); +/** + * Scalar value types. This is a subset of field types declared by protobuf + * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE + * are omitted, but the numerical values are identical. + */ +var ScalarType; +(function (ScalarType) { + // 0 is reserved for errors. + // Order is weird for historical reasons. + ScalarType[ScalarType["DOUBLE"] = 1] = "DOUBLE"; + ScalarType[ScalarType["FLOAT"] = 2] = "FLOAT"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if + // negative values are likely. + ScalarType[ScalarType["INT64"] = 3] = "INT64"; + ScalarType[ScalarType["UINT64"] = 4] = "UINT64"; + // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if + // negative values are likely. + ScalarType[ScalarType["INT32"] = 5] = "INT32"; + ScalarType[ScalarType["FIXED64"] = 6] = "FIXED64"; + ScalarType[ScalarType["FIXED32"] = 7] = "FIXED32"; + ScalarType[ScalarType["BOOL"] = 8] = "BOOL"; + ScalarType[ScalarType["STRING"] = 9] = "STRING"; + // Tag-delimited aggregate. + // Group type is deprecated and not supported in proto3. However, Proto3 + // implementations should still be able to parse the group wire format and + // treat group fields as unknown fields. + // TYPE_GROUP = 10, + // TYPE_MESSAGE = 11, // Length-delimited aggregate. + // New in version 2. + ScalarType[ScalarType["BYTES"] = 12] = "BYTES"; + ScalarType[ScalarType["UINT32"] = 13] = "UINT32"; + // TYPE_ENUM = 14, + ScalarType[ScalarType["SFIXED32"] = 15] = "SFIXED32"; + ScalarType[ScalarType["SFIXED64"] = 16] = "SFIXED64"; + ScalarType[ScalarType["SINT32"] = 17] = "SINT32"; + ScalarType[ScalarType["SINT64"] = 18] = "SINT64"; +})(ScalarType = exports.ScalarType || (exports.ScalarType = {})); +/** + * JavaScript representation of 64 bit integral types. Equivalent to the + * field option "jstype". + * + * By default, protobuf-ts represents 64 bit types as `bigint`. + * + * You can change the default behaviour by enabling the plugin parameter + * `long_type_string`, which will represent 64 bit types as `string`. + * + * Alternatively, you can change the behaviour for individual fields + * with the field option "jstype": + * + * ```protobuf + * uint64 my_field = 1 [jstype = JS_STRING]; + * uint64 other_field = 2 [jstype = JS_NUMBER]; + * ``` + */ +var LongType; +(function (LongType) { + /** + * Use JavaScript `bigint`. + * + * Field option `[jstype = JS_NORMAL]`. + */ + LongType[LongType["BIGINT"] = 0] = "BIGINT"; + /** + * Use JavaScript `string`. + * + * Field option `[jstype = JS_STRING]`. + */ + LongType[LongType["STRING"] = 1] = "STRING"; + /** + * Use JavaScript `number`. + * + * Large values will loose precision. + * + * Field option `[jstype = JS_NUMBER]`. + */ + LongType[LongType["NUMBER"] = 2] = "NUMBER"; +})(LongType = exports.LongType || (exports.LongType = {})); +/** + * Protobuf 2.1.0 introduced packed repeated fields. + * Setting the field option `[packed = true]` enables packing. + * + * In proto3, all repeated fields are packed by default. + * Setting the field option `[packed = false]` disables packing. + * + * Packed repeated fields are encoded with a single tag, + * then a length-delimiter, then the element values. + * + * Unpacked repeated fields are encoded with a tag and + * value for each element. + * + * `bytes` and `string` cannot be packed. + */ +var RepeatType; +(function (RepeatType) { + /** + * The field is not repeated. + */ + RepeatType[RepeatType["NO"] = 0] = "NO"; + /** + * The field is repeated and should be packed. + * Invalid for `bytes` and `string`, they cannot be packed. + */ + RepeatType[RepeatType["PACKED"] = 1] = "PACKED"; + /** + * The field is repeated but should not be packed. + * The only valid repeat type for repeated `bytes` and `string`. + */ + RepeatType[RepeatType["UNPACKED"] = 2] = "UNPACKED"; +})(RepeatType = exports.RepeatType || (exports.RepeatType = {})); +/** + * Turns PartialFieldInfo into FieldInfo. + */ +function normalizeFieldInfo(field) { + var _a, _b, _c, _d; + field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lower_camel_case_1.lowerCamelCase(field.name); + field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lower_camel_case_1.lowerCamelCase(field.name); + field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO; + field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : (field.repeat ? false : field.oneof ? false : field.kind == "message"); + return field; +} +exports.normalizeFieldInfo = normalizeFieldInfo; +/** + * Read custom field options from a generated message type. + * + * @deprecated use readFieldOption() + */ +function readFieldOptions(messageType, fieldName, extensionName, extensionType) { + var _a; + const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options; + return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : undefined; +} +exports.readFieldOptions = readFieldOptions; +function readFieldOption(messageType, fieldName, extensionName, extensionType) { + var _a; + const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options; + if (!options) { + return undefined; + } + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readFieldOption = readFieldOption; +function readMessageOption(messageType, extensionName, extensionType) { + const options = messageType.options; + const optionVal = options[extensionName]; + if (optionVal === undefined) { + return optionVal; + } + return extensionType ? extensionType.fromJson(optionVal) : optionVal; +} +exports.readMessageOption = readMessageOption; + + +/***/ }), + +/***/ 229: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionJsonReader = void 0; +const json_typings_1 = __nccwpck_require__(661); +const base64_1 = __nccwpck_require__(196); +const reflection_info_1 = __nccwpck_require__(1370); +const pb_long_1 = __nccwpck_require__(7777); +const assert_1 = __nccwpck_require__(4253); +const reflection_long_convert_1 = __nccwpck_require__(4612); +/** + * Reads proto3 messages in canonical JSON format using reflection information. + * + * https://developers.google.com/protocol-buffers/docs/proto3#json + */ +class ReflectionJsonReader { + constructor(info) { + this.info = info; + } + prepare() { + var _a; + if (this.fMap === undefined) { + this.fMap = {}; + const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : []; + for (const field of fieldsInput) { + this.fMap[field.name] = field; + this.fMap[field.jsonName] = field; + this.fMap[field.localName] = field; + } + } + } + // Cannot parse JSON for #. + assert(condition, fieldName, jsonValue) { + if (!condition) { + let what = json_typings_1.typeofJsonValue(jsonValue); + if (what == "number" || what == "boolean") + what = jsonValue.toString(); + throw new Error(`Cannot parse JSON ${what} for ${this.info.typeName}#${fieldName}`); + } + } + /** + * Reads a message from canonical JSON format into the target message. + * + * Repeated fields are appended. Map entries are added, overwriting + * existing keys. + * + * If a message field is already present, it will be merged with the + * new data. + */ + read(input, message, options) { + this.prepare(); + const oneofsHandled = []; + for (const [jsonKey, jsonValue] of Object.entries(input)) { + const field = this.fMap[jsonKey]; + if (!field) { + if (!options.ignoreUnknownFields) + throw new Error(`Found unknown field while reading ${this.info.typeName} from JSON format. JSON key: ${jsonKey}`); + continue; + } + const localName = field.localName; + // handle oneof ADT + let target; // this will be the target for the field value, whether it is member of a oneof or not + if (field.oneof) { + if (jsonValue === null && (field.kind !== 'enum' || field.T()[0] !== 'google.protobuf.NullValue')) { + continue; + } + // since json objects are unordered by specification, it is not possible to take the last of multiple oneofs + if (oneofsHandled.includes(field.oneof)) + throw new Error(`Multiple members of the oneof group "${field.oneof}" of ${this.info.typeName} are present in JSON.`); + oneofsHandled.push(field.oneof); + target = message[field.oneof] = { + oneofKind: localName + }; + } + else { + target = message; + } + // we have handled oneof above. we just have read the value into `target`. + if (field.kind == 'map') { + if (jsonValue === null) { + continue; + } + // check input + this.assert(json_typings_1.isJsonObject(jsonValue), field.name, jsonValue); + // our target to put map entries into + const fieldObj = target[localName]; + // read entries + for (const [jsonObjKey, jsonObjValue] of Object.entries(jsonValue)) { + this.assert(jsonObjValue !== null, field.name + " map value", null); + // read value + let val; + switch (field.V.kind) { + case "message": + val = field.V.T().internalJsonRead(jsonObjValue, options); + break; + case "enum": + val = this.enum(field.V.T(), jsonObjValue, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + break; + case "scalar": + val = this.scalar(jsonObjValue, field.V.T, field.V.L, field.name); + break; + } + this.assert(val !== undefined, field.name + " map value", jsonObjValue); + // read key + let key = jsonObjKey; + if (field.K == reflection_info_1.ScalarType.BOOL) + key = key == "true" ? true : key == "false" ? false : key; + key = this.scalar(key, field.K, reflection_info_1.LongType.STRING, field.name).toString(); + fieldObj[key] = val; + } + } + else if (field.repeat) { + if (jsonValue === null) + continue; + // check input + this.assert(Array.isArray(jsonValue), field.name, jsonValue); + // our target to put array entries into + const fieldArr = target[localName]; + // read array entries + for (const jsonItem of jsonValue) { + this.assert(jsonItem !== null, field.name, null); + let val; + switch (field.kind) { + case "message": + val = field.T().internalJsonRead(jsonItem, options); + break; + case "enum": + val = this.enum(field.T(), jsonItem, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + break; + case "scalar": + val = this.scalar(jsonItem, field.T, field.L, field.name); + break; + } + this.assert(val !== undefined, field.name, jsonValue); + fieldArr.push(val); + } + } + else { + switch (field.kind) { + case "message": + if (jsonValue === null && field.T().typeName != 'google.protobuf.Value') { + this.assert(field.oneof === undefined, field.name + " (oneof member)", null); + continue; + } + target[localName] = field.T().internalJsonRead(jsonValue, options, target[localName]); + break; + case "enum": + let val = this.enum(field.T(), jsonValue, field.name, options.ignoreUnknownFields); + if (val === false) + continue; + target[localName] = val; + break; + case "scalar": + target[localName] = this.scalar(jsonValue, field.T, field.L, field.name); + break; + } + } + } + } + /** + * Returns `false` for unrecognized string representations. + * + * google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`). + */ + enum(type, json, fieldName, ignoreUnknownFields) { + if (type[0] == 'google.protobuf.NullValue') + assert_1.assert(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`); + if (json === null) + // we require 0 to be default value for all enums + return 0; + switch (typeof json) { + case "number": + assert_1.assert(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`); + return json; + case "string": + let localEnumName = json; + if (type[2] && json.substring(0, type[2].length) === type[2]) + // lookup without the shared prefix + localEnumName = json.substring(type[2].length); + let enumNumber = type[1][localEnumName]; + if (typeof enumNumber === 'undefined' && ignoreUnknownFields) { + return false; + } + assert_1.assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`); + return enumNumber; + } + assert_1.assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`); + } + scalar(json, type, longType, fieldName) { + let e; + try { + switch (type) { + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + if (json === null) + return .0; + if (json === "NaN") + return Number.NaN; + if (json === "Infinity") + return Number.POSITIVE_INFINITY; + if (json === "-Infinity") + return Number.NEGATIVE_INFINITY; + if (json === "") { + e = "empty string"; + break; + } + if (typeof json == "string" && json.trim().length !== json.length) { + e = "extra whitespace"; + break; + } + if (typeof json != "string" && typeof json != "number") { + break; + } + let float = Number(json); + if (Number.isNaN(float)) { + e = "not a number"; + break; + } + if (!Number.isFinite(float)) { + // infinity and -infinity are handled by string representation above, so this is an error + e = "too large or small"; + break; + } + if (type == reflection_info_1.ScalarType.FLOAT) + assert_1.assertFloat32(float); + return float; + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + case reflection_info_1.ScalarType.UINT32: + if (json === null) + return 0; + let int32; + if (typeof json == "number") + int32 = json; + else if (json === "") + e = "empty string"; + else if (typeof json == "string") { + if (json.trim().length !== json.length) + e = "extra whitespace"; + else + int32 = Number(json); + } + if (int32 === undefined) + break; + if (type == reflection_info_1.ScalarType.UINT32) + assert_1.assertUInt32(int32); + else + assert_1.assertInt32(int32); + return int32; + // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + if (json === null) + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.ZERO, longType); + if (typeof json != "number" && typeof json != "string") + break; + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.from(json), longType); + case reflection_info_1.ScalarType.FIXED64: + case reflection_info_1.ScalarType.UINT64: + if (json === null) + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.ZERO, longType); + if (typeof json != "number" && typeof json != "string") + break; + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.from(json), longType); + // bool: + case reflection_info_1.ScalarType.BOOL: + if (json === null) + return false; + if (typeof json !== "boolean") + break; + return json; + // string: + case reflection_info_1.ScalarType.STRING: + if (json === null) + return ""; + if (typeof json !== "string") { + e = "extra whitespace"; + break; + } + try { + encodeURIComponent(json); + } + catch (e) { + e = "invalid UTF8"; + break; + } + return json; + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case reflection_info_1.ScalarType.BYTES: + if (json === null || json === "") + return new Uint8Array(0); + if (typeof json !== 'string') + break; + return base64_1.base64decode(json); + } + } + catch (error) { + e = error.message; + } + this.assert(false, fieldName + (e ? " - " + e : ""), json); + } +} +exports.ReflectionJsonReader = ReflectionJsonReader; + + +/***/ }), + +/***/ 8980: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionJsonWriter = void 0; +const base64_1 = __nccwpck_require__(196); +const pb_long_1 = __nccwpck_require__(7777); +const reflection_info_1 = __nccwpck_require__(1370); +const assert_1 = __nccwpck_require__(4253); +/** + * Writes proto3 messages in canonical JSON format using reflection + * information. + * + * https://developers.google.com/protocol-buffers/docs/proto3#json + */ +class ReflectionJsonWriter { + constructor(info) { + var _a; + this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : []; + } + /** + * Converts the message to a JSON object, based on the field descriptors. + */ + write(message, options) { + const json = {}, source = message; + for (const field of this.fields) { + // field is not part of a oneof, simply write as is + if (!field.oneof) { + let jsonValue = this.field(field, source[field.localName], options); + if (jsonValue !== undefined) + json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue; + continue; + } + // field is part of a oneof + const group = source[field.oneof]; + if (group.oneofKind !== field.localName) + continue; // not selected, skip + const opt = field.kind == 'scalar' || field.kind == 'enum' + ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options; + let jsonValue = this.field(field, group[field.localName], opt); + assert_1.assert(jsonValue !== undefined); + json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue; + } + return json; + } + field(field, value, options) { + let jsonValue = undefined; + if (field.kind == 'map') { + assert_1.assert(typeof value == "object" && value !== null); + const jsonObj = {}; + switch (field.V.kind) { + case "scalar": + for (const [entryKey, entryValue] of Object.entries(value)) { + const val = this.scalar(field.V.T, entryValue, field.name, false, true); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + case "message": + const messageType = field.V.T(); + for (const [entryKey, entryValue] of Object.entries(value)) { + const val = this.message(messageType, entryValue, field.name, options); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + case "enum": + const enumInfo = field.V.T(); + for (const [entryKey, entryValue] of Object.entries(value)) { + assert_1.assert(entryValue === undefined || typeof entryValue == 'number'); + const val = this.enum(enumInfo, entryValue, field.name, false, true, options.enumAsInteger); + assert_1.assert(val !== undefined); + jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key + } + break; + } + if (options.emitDefaultValues || Object.keys(jsonObj).length > 0) + jsonValue = jsonObj; + } + else if (field.repeat) { + assert_1.assert(Array.isArray(value)); + const jsonArr = []; + switch (field.kind) { + case "scalar": + for (let i = 0; i < value.length; i++) { + const val = this.scalar(field.T, value[i], field.name, field.opt, true); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + case "enum": + const enumInfo = field.T(); + for (let i = 0; i < value.length; i++) { + assert_1.assert(value[i] === undefined || typeof value[i] == 'number'); + const val = this.enum(enumInfo, value[i], field.name, field.opt, true, options.enumAsInteger); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + case "message": + const messageType = field.T(); + for (let i = 0; i < value.length; i++) { + const val = this.message(messageType, value[i], field.name, options); + assert_1.assert(val !== undefined); + jsonArr.push(val); + } + break; + } + // add converted array to json output + if (options.emitDefaultValues || jsonArr.length > 0 || options.emitDefaultValues) + jsonValue = jsonArr; + } + else { + switch (field.kind) { + case "scalar": + jsonValue = this.scalar(field.T, value, field.name, field.opt, options.emitDefaultValues); + break; + case "enum": + jsonValue = this.enum(field.T(), value, field.name, field.opt, options.emitDefaultValues, options.enumAsInteger); + break; + case "message": + jsonValue = this.message(field.T(), value, field.name, options); + break; + } + } + return jsonValue; + } + /** + * Returns `null` as the default for google.protobuf.NullValue. + */ + enum(type, value, fieldName, optional, emitDefaultValues, enumAsInteger) { + if (type[0] == 'google.protobuf.NullValue') + return !emitDefaultValues && !optional ? undefined : null; + if (value === undefined) { + assert_1.assert(optional); + return undefined; + } + if (value === 0 && !emitDefaultValues && !optional) + // we require 0 to be default value for all enums + return undefined; + assert_1.assert(typeof value == 'number'); + assert_1.assert(Number.isInteger(value)); + if (enumAsInteger || !type[1].hasOwnProperty(value)) + // if we don't now the enum value, just return the number + return value; + if (type[2]) + // restore the dropped prefix + return type[2] + type[1][value]; + return type[1][value]; + } + message(type, value, fieldName, options) { + if (value === undefined) + return options.emitDefaultValues ? null : undefined; + return type.internalJsonWrite(value, options); + } + scalar(type, value, fieldName, optional, emitDefaultValues) { + if (value === undefined) { + assert_1.assert(optional); + return undefined; + } + const ed = emitDefaultValues || optional; + // noinspection FallThroughInSwitchStatementJS + switch (type) { + // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assertInt32(value); + return value; + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.UINT32: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assertUInt32(value); + return value; + // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity". + // Either numbers or strings are accepted. Exponent notation is also accepted. + case reflection_info_1.ScalarType.FLOAT: + assert_1.assertFloat32(value); + case reflection_info_1.ScalarType.DOUBLE: + if (value === 0) + return ed ? 0 : undefined; + assert_1.assert(typeof value == 'number'); + if (Number.isNaN(value)) + return 'NaN'; + if (value === Number.POSITIVE_INFINITY) + return 'Infinity'; + if (value === Number.NEGATIVE_INFINITY) + return '-Infinity'; + return value; + // string: + case reflection_info_1.ScalarType.STRING: + if (value === "") + return ed ? '' : undefined; + assert_1.assert(typeof value == 'string'); + return value; + // bool: + case reflection_info_1.ScalarType.BOOL: + if (value === false) + return ed ? false : undefined; + assert_1.assert(typeof value == 'boolean'); + return value; + // JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + assert_1.assert(typeof value == 'number' || typeof value == 'string' || typeof value == 'bigint'); + let ulong = pb_long_1.PbULong.from(value); + if (ulong.isZero() && !ed) + return undefined; + return ulong.toString(); + // JSON value will be a decimal string. Either numbers or strings are accepted. + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + assert_1.assert(typeof value == 'number' || typeof value == 'string' || typeof value == 'bigint'); + let long = pb_long_1.PbLong.from(value); + if (long.isZero() && !ed) + return undefined; + return long.toString(); + // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings. + // Either standard or URL-safe base64 encoding with/without paddings are accepted. + case reflection_info_1.ScalarType.BYTES: + assert_1.assert(value instanceof Uint8Array); + if (!value.byteLength) + return ed ? "" : undefined; + return base64_1.base64encode(value); + } + } +} +exports.ReflectionJsonWriter = ReflectionJsonWriter; + + +/***/ }), + +/***/ 4612: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionLongConvert = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +/** + * Utility method to convert a PbLong or PbUlong to a JavaScript + * representation during runtime. + * + * Works with generated field information, `undefined` is equivalent + * to `STRING`. + */ +function reflectionLongConvert(long, type) { + switch (type) { + case reflection_info_1.LongType.BIGINT: + return long.toBigInt(); + case reflection_info_1.LongType.NUMBER: + return long.toNumber(); + default: + // case undefined: + // case LongType.STRING: + return long.toString(); + } +} +exports.reflectionLongConvert = reflectionLongConvert; + + +/***/ }), + +/***/ 7869: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionMergePartial = void 0; +/** + * Copy partial data into the target message. + * + * If a singular scalar or enum field is present in the source, it + * replaces the field in the target. + * + * If a singular message field is present in the source, it is merged + * with the target field by calling mergePartial() of the responsible + * message type. + * + * If a repeated field is present in the source, its values replace + * all values in the target array, removing extraneous values. + * Repeated message fields are copied, not merged. + * + * If a map field is present in the source, entries are added to the + * target map, replacing entries with the same key. Entries that only + * exist in the target remain. Entries with message values are copied, + * not merged. + * + * Note that this function differs from protobuf merge semantics, + * which appends repeated fields. + */ +function reflectionMergePartial(info, target, source) { + let fieldValue, // the field value we are working with + input = source, output; // where we want our field value to go + for (let field of info.fields) { + let name = field.localName; + if (field.oneof) { + const group = input[field.oneof]; // this is the oneof`s group in the source + if ((group === null || group === void 0 ? void 0 : group.oneofKind) == undefined) { // the user is free to omit + continue; // we skip this field, and all other members too + } + fieldValue = group[name]; // our value comes from the the oneof group of the source + output = target[field.oneof]; // and our output is the oneof group of the target + output.oneofKind = group.oneofKind; // always update discriminator + if (fieldValue == undefined) { + delete output[name]; // remove any existing value + continue; // skip further work on field + } + } + else { + fieldValue = input[name]; // we are using the source directly + output = target; // we want our field value to go directly into the target + if (fieldValue == undefined) { + continue; // skip further work on field, existing value is used as is + } + } + if (field.repeat) + output[name].length = fieldValue.length; // resize target array to match source array + // now we just work with `fieldValue` and `output` to merge the value + switch (field.kind) { + case "scalar": + case "enum": + if (field.repeat) + for (let i = 0; i < fieldValue.length; i++) + output[name][i] = fieldValue[i]; // not a reference type + else + output[name] = fieldValue; // not a reference type + break; + case "message": + let T = field.T(); + if (field.repeat) + for (let i = 0; i < fieldValue.length; i++) + output[name][i] = T.create(fieldValue[i]); + else if (output[name] === undefined) + output[name] = T.create(fieldValue); // nothing to merge with + else + T.mergePartial(output[name], fieldValue); + break; + case "map": + // Map and repeated fields are simply overwritten, not appended or merged + switch (field.V.kind) { + case "scalar": + case "enum": + Object.assign(output[name], fieldValue); // elements are not reference types + break; + case "message": + let T = field.V.T(); + for (let k of Object.keys(fieldValue)) + output[name][k] = T.create(fieldValue[k]); + break; + } + break; + } + } +} +exports.reflectionMergePartial = reflectionMergePartial; + + +/***/ }), + +/***/ 4863: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.reflectionScalarDefault = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +const reflection_long_convert_1 = __nccwpck_require__(4612); +const pb_long_1 = __nccwpck_require__(7777); +/** + * Creates the default value for a scalar type. + */ +function reflectionScalarDefault(type, longType = reflection_info_1.LongType.STRING) { + switch (type) { + case reflection_info_1.ScalarType.BOOL: + return false; + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.ZERO, longType); + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.ZERO, longType); + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + return 0.0; + case reflection_info_1.ScalarType.BYTES: + return new Uint8Array(0); + case reflection_info_1.ScalarType.STRING: + return ""; + default: + // case ScalarType.INT32: + // case ScalarType.UINT32: + // case ScalarType.SINT32: + // case ScalarType.FIXED32: + // case ScalarType.SFIXED32: + return 0; + } +} +exports.reflectionScalarDefault = reflectionScalarDefault; + + +/***/ }), + +/***/ 903: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ReflectionTypeCheck = void 0; +const reflection_info_1 = __nccwpck_require__(1370); +const oneof_1 = __nccwpck_require__(8531); +// noinspection JSMethodCanBeStatic +class ReflectionTypeCheck { + constructor(info) { + var _a; + this.fields = (_a = info.fields) !== null && _a !== void 0 ? _a : []; + } + prepare() { + if (this.data) + return; + const req = [], known = [], oneofs = []; + for (let field of this.fields) { + if (field.oneof) { + if (!oneofs.includes(field.oneof)) { + oneofs.push(field.oneof); + req.push(field.oneof); + known.push(field.oneof); + } + } + else { + known.push(field.localName); + switch (field.kind) { + case "scalar": + case "enum": + if (!field.opt || field.repeat) + req.push(field.localName); + break; + case "message": + if (field.repeat) + req.push(field.localName); + break; + case "map": + req.push(field.localName); + break; + } + } + } + this.data = { req, known, oneofs: Object.values(oneofs) }; + } + /** + * Is the argument a valid message as specified by the + * reflection information? + * + * Checks all field types recursively. The `depth` + * specifies how deep into the structure the check will be. + * + * With a depth of 0, only the presence of fields + * is checked. + * + * With a depth of 1 or more, the field types are checked. + * + * With a depth of 2 or more, the members of map, repeated + * and message fields are checked. + * + * Message fields will be checked recursively with depth - 1. + * + * The number of map entries / repeated values being checked + * is < depth. + */ + is(message, depth, allowExcessProperties = false) { + if (depth < 0) + return true; + if (message === null || message === undefined || typeof message != 'object') + return false; + this.prepare(); + let keys = Object.keys(message), data = this.data; + // if a required field is missing in arg, this cannot be a T + if (keys.length < data.req.length || data.req.some(n => !keys.includes(n))) + return false; + if (!allowExcessProperties) { + // if the arg contains a key we dont know, this is not a literal T + if (keys.some(k => !data.known.includes(k))) + return false; + } + // "With a depth of 0, only the presence and absence of fields is checked." + // "With a depth of 1 or more, the field types are checked." + if (depth < 1) { + return true; + } + // check oneof group + for (const name of data.oneofs) { + const group = message[name]; + if (!oneof_1.isOneofGroup(group)) + return false; + if (group.oneofKind === undefined) + continue; + const field = this.fields.find(f => f.localName === group.oneofKind); + if (!field) + return false; // we found no field, but have a kind, something is wrong + if (!this.field(group[group.oneofKind], field, allowExcessProperties, depth)) + return false; + } + // check types + for (const field of this.fields) { + if (field.oneof !== undefined) + continue; + if (!this.field(message[field.localName], field, allowExcessProperties, depth)) + return false; + } + return true; + } + field(arg, field, allowExcessProperties, depth) { + let repeated = field.repeat; + switch (field.kind) { + case "scalar": + if (arg === undefined) + return field.opt; + if (repeated) + return this.scalars(arg, field.T, depth, field.L); + return this.scalar(arg, field.T, field.L); + case "enum": + if (arg === undefined) + return field.opt; + if (repeated) + return this.scalars(arg, reflection_info_1.ScalarType.INT32, depth); + return this.scalar(arg, reflection_info_1.ScalarType.INT32); + case "message": + if (arg === undefined) + return true; + if (repeated) + return this.messages(arg, field.T(), allowExcessProperties, depth); + return this.message(arg, field.T(), allowExcessProperties, depth); + case "map": + if (typeof arg != 'object' || arg === null) + return false; + if (depth < 2) + return true; + if (!this.mapKeys(arg, field.K, depth)) + return false; + switch (field.V.kind) { + case "scalar": + return this.scalars(Object.values(arg), field.V.T, depth, field.V.L); + case "enum": + return this.scalars(Object.values(arg), reflection_info_1.ScalarType.INT32, depth); + case "message": + return this.messages(Object.values(arg), field.V.T(), allowExcessProperties, depth); + } + break; + } + return true; + } + message(arg, type, allowExcessProperties, depth) { + if (allowExcessProperties) { + return type.isAssignable(arg, depth); + } + return type.is(arg, depth); + } + messages(arg, type, allowExcessProperties, depth) { + if (!Array.isArray(arg)) + return false; + if (depth < 2) + return true; + if (allowExcessProperties) { + for (let i = 0; i < arg.length && i < depth; i++) + if (!type.isAssignable(arg[i], depth - 1)) + return false; + } + else { + for (let i = 0; i < arg.length && i < depth; i++) + if (!type.is(arg[i], depth - 1)) + return false; + } + return true; + } + scalar(arg, type, longType) { + let argType = typeof arg; + switch (type) { + case reflection_info_1.ScalarType.UINT64: + case reflection_info_1.ScalarType.FIXED64: + case reflection_info_1.ScalarType.INT64: + case reflection_info_1.ScalarType.SFIXED64: + case reflection_info_1.ScalarType.SINT64: + switch (longType) { + case reflection_info_1.LongType.BIGINT: + return argType == "bigint"; + case reflection_info_1.LongType.NUMBER: + return argType == "number" && !isNaN(arg); + default: + return argType == "string"; + } + case reflection_info_1.ScalarType.BOOL: + return argType == 'boolean'; + case reflection_info_1.ScalarType.STRING: + return argType == 'string'; + case reflection_info_1.ScalarType.BYTES: + return arg instanceof Uint8Array; + case reflection_info_1.ScalarType.DOUBLE: + case reflection_info_1.ScalarType.FLOAT: + return argType == 'number' && !isNaN(arg); + default: + // case ScalarType.UINT32: + // case ScalarType.FIXED32: + // case ScalarType.INT32: + // case ScalarType.SINT32: + // case ScalarType.SFIXED32: + return argType == 'number' && Number.isInteger(arg); + } + } + scalars(arg, type, depth, longType) { + if (!Array.isArray(arg)) + return false; + if (depth < 2) + return true; + if (Array.isArray(arg)) + for (let i = 0; i < arg.length && i < depth; i++) + if (!this.scalar(arg[i], type, longType)) + return false; + return true; + } + mapKeys(map, type, depth) { + let keys = Object.keys(map); + switch (type) { + case reflection_info_1.ScalarType.INT32: + case reflection_info_1.ScalarType.FIXED32: + case reflection_info_1.ScalarType.SFIXED32: + case reflection_info_1.ScalarType.SINT32: + case reflection_info_1.ScalarType.UINT32: + return this.scalars(keys.slice(0, depth).map(k => parseInt(k)), type, depth); + case reflection_info_1.ScalarType.BOOL: + return this.scalars(keys.slice(0, depth).map(k => k == 'true' ? true : k == 'false' ? false : k), type, depth); + default: + return this.scalars(keys, type, depth, reflection_info_1.LongType.STRING); + } + } +} +exports.ReflectionTypeCheck = ReflectionTypeCheck; + + /***/ }), /***/ 4812: @@ -52099,6 +58978,599 @@ DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() { }; +/***/ }), + +/***/ 4365: +/***/ ((module) => { + +"use strict"; + + +function _process (v, mod) { + var i + var r + + if (typeof mod === 'function') { + r = mod(v) + if (r !== undefined) { + v = r + } + } else if (Array.isArray(mod)) { + for (i = 0; i < mod.length; i++) { + r = mod[i](v) + if (r !== undefined) { + v = r + } + } + } + + return v +} + +function parseKey (key, val) { + // detect negative index notation + if (key[0] === '-' && Array.isArray(val) && /^-\d+$/.test(key)) { + return val.length + parseInt(key, 10) + } + return key +} + +function isIndex (k) { + return /^\d+$/.test(k) +} + +function isObject (val) { + return Object.prototype.toString.call(val) === '[object Object]' +} + +function isArrayOrObject (val) { + return Object(val) === val +} + +function isEmptyObject (val) { + return Object.keys(val).length === 0 +} + +var blacklist = ['__proto__', 'prototype', 'constructor'] +var blacklistFilter = function (part) { return blacklist.indexOf(part) === -1 } + +function parsePath (path, sep) { + if (path.indexOf('[') >= 0) { + path = path.replace(/\[/g, sep).replace(/]/g, '') + } + + var parts = path.split(sep) + + var check = parts.filter(blacklistFilter) + + if (check.length !== parts.length) { + throw Error('Refusing to update blacklisted property ' + path) + } + + return parts +} + +var hasOwnProperty = Object.prototype.hasOwnProperty + +function DotObject (separator, override, useArray, useBrackets) { + if (!(this instanceof DotObject)) { + return new DotObject(separator, override, useArray, useBrackets) + } + + if (typeof override === 'undefined') override = false + if (typeof useArray === 'undefined') useArray = true + if (typeof useBrackets === 'undefined') useBrackets = true + this.separator = separator || '.' + this.override = override + this.useArray = useArray + this.useBrackets = useBrackets + this.keepArray = false + + // contains touched arrays + this.cleanup = [] +} + +var dotDefault = new DotObject('.', false, true, true) +function wrap (method) { + return function () { + return dotDefault[method].apply(dotDefault, arguments) + } +} + +DotObject.prototype._fill = function (a, obj, v, mod) { + var k = a.shift() + + if (a.length > 0) { + obj[k] = obj[k] || (this.useArray && isIndex(a[0]) ? [] : {}) + + if (!isArrayOrObject(obj[k])) { + if (this.override) { + obj[k] = {} + } else { + if (!(isArrayOrObject(v) && isEmptyObject(v))) { + throw new Error( + 'Trying to redefine `' + k + '` which is a ' + typeof obj[k] + ) + } + + return + } + } + + this._fill(a, obj[k], v, mod) + } else { + if (!this.override && isArrayOrObject(obj[k]) && !isEmptyObject(obj[k])) { + if (!(isArrayOrObject(v) && isEmptyObject(v))) { + throw new Error("Trying to redefine non-empty obj['" + k + "']") + } + + return + } + + obj[k] = _process(v, mod) + } +} + +/** + * + * Converts an object with dotted-key/value pairs to it's expanded version + * + * Optionally transformed by a set of modifiers. + * + * Usage: + * + * var row = { + * 'nr': 200, + * 'doc.name': ' My Document ' + * } + * + * var mods = { + * 'doc.name': [_s.trim, _s.underscored] + * } + * + * dot.object(row, mods) + * + * @param {Object} obj + * @param {Object} mods + */ +DotObject.prototype.object = function (obj, mods) { + var self = this + + Object.keys(obj).forEach(function (k) { + var mod = mods === undefined ? null : mods[k] + // normalize array notation. + var ok = parsePath(k, self.separator).join(self.separator) + + if (ok.indexOf(self.separator) !== -1) { + self._fill(ok.split(self.separator), obj, obj[k], mod) + delete obj[k] + } else { + obj[k] = _process(obj[k], mod) + } + }) + + return obj +} + +/** + * @param {String} path dotted path + * @param {String} v value to be set + * @param {Object} obj object to be modified + * @param {Function|Array} mod optional modifier + */ +DotObject.prototype.str = function (path, v, obj, mod) { + var ok = parsePath(path, this.separator).join(this.separator) + + if (path.indexOf(this.separator) !== -1) { + this._fill(ok.split(this.separator), obj, v, mod) + } else { + obj[path] = _process(v, mod) + } + + return obj +} + +/** + * + * Pick a value from an object using dot notation. + * + * Optionally remove the value + * + * @param {String} path + * @param {Object} obj + * @param {Boolean} remove + */ +DotObject.prototype.pick = function (path, obj, remove, reindexArray) { + var i + var keys + var val + var key + var cp + + keys = parsePath(path, this.separator) + for (i = 0; i < keys.length; i++) { + key = parseKey(keys[i], obj) + if (obj && typeof obj === 'object' && key in obj) { + if (i === keys.length - 1) { + if (remove) { + val = obj[key] + if (reindexArray && Array.isArray(obj)) { + obj.splice(key, 1) + } else { + delete obj[key] + } + if (Array.isArray(obj)) { + cp = keys.slice(0, -1).join('.') + if (this.cleanup.indexOf(cp) === -1) { + this.cleanup.push(cp) + } + } + return val + } else { + return obj[key] + } + } else { + obj = obj[key] + } + } else { + return undefined + } + } + if (remove && Array.isArray(obj)) { + obj = obj.filter(function (n) { + return n !== undefined + }) + } + return obj +} +/** + * + * Delete value from an object using dot notation. + * + * @param {String} path + * @param {Object} obj + * @return {any} The removed value + */ +DotObject.prototype.delete = function (path, obj) { + return this.remove(path, obj, true) +} + +/** + * + * Remove value from an object using dot notation. + * + * Will remove multiple items if path is an array. + * In this case array indexes will be retained until all + * removals have been processed. + * + * Use dot.delete() to automatically re-index arrays. + * + * @param {String|Array} path + * @param {Object} obj + * @param {Boolean} reindexArray + * @return {any} The removed value + */ +DotObject.prototype.remove = function (path, obj, reindexArray) { + var i + + this.cleanup = [] + if (Array.isArray(path)) { + for (i = 0; i < path.length; i++) { + this.pick(path[i], obj, true, reindexArray) + } + if (!reindexArray) { + this._cleanup(obj) + } + return obj + } else { + return this.pick(path, obj, true, reindexArray) + } +} + +DotObject.prototype._cleanup = function (obj) { + var ret + var i + var keys + var root + if (this.cleanup.length) { + for (i = 0; i < this.cleanup.length; i++) { + keys = this.cleanup[i].split('.') + root = keys.splice(0, -1).join('.') + ret = root ? this.pick(root, obj) : obj + ret = ret[keys[0]].filter(function (v) { + return v !== undefined + }) + this.set(this.cleanup[i], ret, obj) + } + this.cleanup = [] + } +} + +/** + * Alias method for `dot.remove` + * + * Note: this is not an alias for dot.delete() + * + * @param {String|Array} path + * @param {Object} obj + * @param {Boolean} reindexArray + * @return {any} The removed value + */ +DotObject.prototype.del = DotObject.prototype.remove + +/** + * + * Move a property from one place to the other. + * + * If the source path does not exist (undefined) + * the target property will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.move = function (source, target, obj, mods, merge) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set(target, _process(this.pick(source, obj, true), mods), obj, merge) + } else { + merge = mods + this.set(target, this.pick(source, obj, true), obj, merge) + } + + return obj +} + +/** + * + * Transfer a property from one object to another object. + * + * If the source path does not exist (undefined) + * the property on the other object will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj1 + * @param {Object} obj2 + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.transfer = function ( + source, + target, + obj1, + obj2, + mods, + merge +) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set( + target, + _process(this.pick(source, obj1, true), mods), + obj2, + merge + ) + } else { + merge = mods + this.set(target, this.pick(source, obj1, true), obj2, merge) + } + + return obj2 +} + +/** + * + * Copy a property from one object to another object. + * + * If the source path does not exist (undefined) + * the property on the other object will not be set. + * + * @param {String} source + * @param {String} target + * @param {Object} obj1 + * @param {Object} obj2 + * @param {Function|Array} mods + * @param {Boolean} merge + */ +DotObject.prototype.copy = function (source, target, obj1, obj2, mods, merge) { + if (typeof mods === 'function' || Array.isArray(mods)) { + this.set( + target, + _process( + // clone what is picked + JSON.parse(JSON.stringify(this.pick(source, obj1, false))), + mods + ), + obj2, + merge + ) + } else { + merge = mods + this.set(target, this.pick(source, obj1, false), obj2, merge) + } + + return obj2 +} + +/** + * + * Set a property on an object using dot notation. + * + * @param {String} path + * @param {any} val + * @param {Object} obj + * @param {Boolean} merge + */ +DotObject.prototype.set = function (path, val, obj, merge) { + var i + var k + var keys + var key + + // Do not operate if the value is undefined. + if (typeof val === 'undefined') { + return obj + } + keys = parsePath(path, this.separator) + + for (i = 0; i < keys.length; i++) { + key = keys[i] + if (i === keys.length - 1) { + if (merge && isObject(val) && isObject(obj[key])) { + for (k in val) { + if (hasOwnProperty.call(val, k)) { + obj[key][k] = val[k] + } + } + } else if (merge && Array.isArray(obj[key]) && Array.isArray(val)) { + for (var j = 0; j < val.length; j++) { + obj[keys[i]].push(val[j]) + } + } else { + obj[key] = val + } + } else if ( + // force the value to be an object + !hasOwnProperty.call(obj, key) || + (!isObject(obj[key]) && !Array.isArray(obj[key])) + ) { + // initialize as array if next key is numeric + if (/^\d+$/.test(keys[i + 1])) { + obj[key] = [] + } else { + obj[key] = {} + } + } + obj = obj[key] + } + return obj +} + +/** + * + * Transform an object + * + * Usage: + * + * var obj = { + * "id": 1, + * "some": { + * "thing": "else" + * } + * } + * + * var transform = { + * "id": "nr", + * "some.thing": "name" + * } + * + * var tgt = dot.transform(transform, obj) + * + * @param {Object} recipe Transform recipe + * @param {Object} obj Object to be transformed + * @param {Array} mods modifiers for the target + */ +DotObject.prototype.transform = function (recipe, obj, tgt) { + obj = obj || {} + tgt = tgt || {} + Object.keys(recipe).forEach( + function (key) { + this.set(recipe[key], this.pick(key, obj), tgt) + }.bind(this) + ) + return tgt +} + +/** + * + * Convert object to dotted-key/value pair + * + * Usage: + * + * var tgt = dot.dot(obj) + * + * or + * + * var tgt = {} + * dot.dot(obj, tgt) + * + * @param {Object} obj source object + * @param {Object} tgt target object + * @param {Array} path path array (internal) + */ +DotObject.prototype.dot = function (obj, tgt, path) { + tgt = tgt || {} + path = path || [] + var isArray = Array.isArray(obj) + + Object.keys(obj).forEach( + function (key) { + var index = isArray && this.useBrackets ? '[' + key + ']' : key + if ( + isArrayOrObject(obj[key]) && + ((isObject(obj[key]) && !isEmptyObject(obj[key])) || + (Array.isArray(obj[key]) && !this.keepArray && obj[key].length !== 0)) + ) { + if (isArray && this.useBrackets) { + var previousKey = path[path.length - 1] || '' + return this.dot( + obj[key], + tgt, + path.slice(0, -1).concat(previousKey + index) + ) + } else { + return this.dot(obj[key], tgt, path.concat(index)) + } + } else { + if (isArray && this.useBrackets) { + tgt[path.join(this.separator).concat('[' + key + ']')] = obj[key] + } else { + tgt[path.concat(index).join(this.separator)] = obj[key] + } + } + }.bind(this) + ) + return tgt +} + +DotObject.pick = wrap('pick') +DotObject.move = wrap('move') +DotObject.transfer = wrap('transfer') +DotObject.transform = wrap('transform') +DotObject.copy = wrap('copy') +DotObject.object = wrap('object') +DotObject.str = wrap('str') +DotObject.set = wrap('set') +DotObject.delete = wrap('delete') +DotObject.del = DotObject.remove = wrap('remove') +DotObject.dot = wrap('dot'); +['override', 'overwrite'].forEach(function (prop) { + Object.defineProperty(DotObject, prop, { + get: function () { + return dotDefault.override + }, + set: function (val) { + dotDefault.override = !!val + } + }) +}); +['useArray', 'keepArray', 'useBrackets'].forEach(function (prop) { + Object.defineProperty(DotObject, prop, { + get: function () { + return dotDefault[prop] + }, + set: function (val) { + dotDefault[prop] = val + } + }) +}) + +DotObject._process = _process + +module.exports = DotObject + + /***/ }), /***/ 7426: @@ -56787,7 +64259,7 @@ module.exports = Comparator const parseOptions = __nccwpck_require__(785) const { safeRe: re, t } = __nccwpck_require__(9523) const cmp = __nccwpck_require__(5098) -const debug = __nccwpck_require__(106) +const debug = __nccwpck_require__(427) const SemVer = __nccwpck_require__(8088) const Range = __nccwpck_require__(9828) @@ -57002,7 +64474,7 @@ const cache = new LRU({ max: 1000 }) const parseOptions = __nccwpck_require__(785) const Comparator = __nccwpck_require__(1532) -const debug = __nccwpck_require__(106) +const debug = __nccwpck_require__(427) const SemVer = __nccwpck_require__(8088) const { safeRe: re, @@ -57343,7 +64815,7 @@ const testSet = (set, version, options) => { /***/ 8088: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const debug = __nccwpck_require__(106) +const debug = __nccwpck_require__(427) const { MAX_LENGTH, MAX_SAFE_INTEGER } = __nccwpck_require__(2293) const { safeRe: re, t } = __nccwpck_require__(9523) @@ -58150,7 +65622,7 @@ const validRange = __nccwpck_require__(2098) const outside = __nccwpck_require__(420) const gtr = __nccwpck_require__(9380) const ltr = __nccwpck_require__(3323) -const intersects = __nccwpck_require__(7008) +const intersects = __nccwpck_require__(2988) const simplifyRange = __nccwpck_require__(5297) const subset = __nccwpck_require__(7863) module.exports = { @@ -58246,7 +65718,7 @@ module.exports = { /***/ }), -/***/ 106: +/***/ 427: /***/ ((module) => { const debug = ( @@ -58322,7 +65794,7 @@ const { MAX_SAFE_BUILD_LENGTH, MAX_LENGTH, } = __nccwpck_require__(2293) -const debug = __nccwpck_require__(106) +const debug = __nccwpck_require__(427) exports = module.exports = {} // The actual regexps go on exports.re @@ -59341,7 +66813,7 @@ module.exports = gtr /***/ }), -/***/ 7008: +/***/ 2988: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { const Range = __nccwpck_require__(9828) @@ -60832,6 +68304,1152 @@ if (process.env.NODE_DEBUG && /\btunnel\b/.test(process.env.NODE_DEBUG)) { exports.debug = debug; // for test +/***/ }), + +/***/ 1524: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); + + +/***/ }), + +/***/ 6647: +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isValidErrorCode = exports.httpStatusFromErrorCode = exports.TwirpErrorCode = exports.BadRouteError = exports.InternalServerErrorWith = exports.InternalServerError = exports.RequiredArgumentError = exports.InvalidArgumentError = exports.NotFoundError = exports.TwirpError = void 0; +/** + * Represents a twirp error + */ +class TwirpError extends Error { + constructor(code, msg) { + super(msg); + this.code = TwirpErrorCode.Internal; + this.meta = {}; + this.code = code; + this.msg = msg; + Object.setPrototypeOf(this, TwirpError.prototype); + } + /** + * Adds a metadata kv to the error + * @param key + * @param value + */ + withMeta(key, value) { + this.meta[key] = value; + return this; + } + /** + * Returns a single metadata value + * return "" if not found + * @param key + */ + getMeta(key) { + return this.meta[key] || ""; + } + /** + * Add the original error cause + * @param err + * @param addMeta + */ + withCause(err, addMeta = false) { + this._originalCause = err; + if (addMeta) { + this.withMeta("cause", err.message); + } + return this; + } + cause() { + return this._originalCause; + } + /** + * Returns the error representation to JSON + */ + toJSON() { + try { + return JSON.stringify({ + code: this.code, + msg: this.msg, + meta: this.meta, + }); + } + catch (e) { + return `{"code": "internal", "msg": "There was an error but it could not be serialized into JSON"}`; + } + } + /** + * Create a twirp error from an object + * @param obj + */ + static fromObject(obj) { + const code = obj["code"] || TwirpErrorCode.Unknown; + const msg = obj["msg"] || "unknown"; + const error = new TwirpError(code, msg); + if (obj["meta"]) { + Object.keys(obj["meta"]).forEach((key) => { + error.withMeta(key, obj["meta"][key]); + }); + } + return error; + } +} +exports.TwirpError = TwirpError; +/** + * NotFoundError constructor for the common NotFound error. + */ +class NotFoundError extends TwirpError { + constructor(msg) { + super(TwirpErrorCode.NotFound, msg); + } +} +exports.NotFoundError = NotFoundError; +/** + * InvalidArgumentError constructor for the common InvalidArgument error. Can be + * used when an argument has invalid format, is a number out of range, is a bad + * option, etc). + */ +class InvalidArgumentError extends TwirpError { + constructor(argument, validationMsg) { + super(TwirpErrorCode.InvalidArgument, argument + " " + validationMsg); + this.withMeta("argument", argument); + } +} +exports.InvalidArgumentError = InvalidArgumentError; +/** + * RequiredArgumentError is a more specific constructor for InvalidArgument + * error. Should be used when the argument is required (expected to have a + * non-zero value). + */ +class RequiredArgumentError extends InvalidArgumentError { + constructor(argument) { + super(argument, "is required"); + } +} +exports.RequiredArgumentError = RequiredArgumentError; +/** + * InternalError constructor for the common Internal error. Should be used to + * specify that something bad or unexpected happened. + */ +class InternalServerError extends TwirpError { + constructor(msg) { + super(TwirpErrorCode.Internal, msg); + } +} +exports.InternalServerError = InternalServerError; +/** + * InternalErrorWith makes an internal error, wrapping the original error and using it + * for the error message, and with metadata "cause" with the original error type. + * This function is used by Twirp services to wrap non-Twirp errors as internal errors. + * The wrapped error can be extracted later with err.cause() + */ +class InternalServerErrorWith extends InternalServerError { + constructor(err) { + super(err.message); + this.withMeta("cause", err.name); + this.withCause(err); + } +} +exports.InternalServerErrorWith = InternalServerErrorWith; +/** + * A standard BadRoute Error + */ +class BadRouteError extends TwirpError { + constructor(msg, method, url) { + super(TwirpErrorCode.BadRoute, msg); + this.withMeta("twirp_invalid_route", method + " " + url); + } +} +exports.BadRouteError = BadRouteError; +var TwirpErrorCode; +(function (TwirpErrorCode) { + // Canceled indicates the operation was cancelled (typically by the caller). + TwirpErrorCode["Canceled"] = "canceled"; + // Unknown error. For example when handling errors raised by APIs that do not + // return enough error information. + TwirpErrorCode["Unknown"] = "unknown"; + // InvalidArgument indicates client specified an invalid argument. It + // indicates arguments that are problematic regardless of the state of the + // system (i.e. a malformed file name, required argument, number out of range, + // etc.). + TwirpErrorCode["InvalidArgument"] = "invalid_argument"; + // Malformed indicates an error occurred while decoding the client's request. + // This may mean that the message was encoded improperly, or that there is a + // disagreement in message format between the client and server. + TwirpErrorCode["Malformed"] = "malformed"; + // DeadlineExceeded means operation expired before completion. For operations + // that change the state of the system, this error may be returned even if the + // operation has completed successfully (timeout). + TwirpErrorCode["DeadlineExceeded"] = "deadline_exceeded"; + // NotFound means some requested entity was not found. + TwirpErrorCode["NotFound"] = "not_found"; + // BadRoute means that the requested URL path wasn't routable to a Twirp + // service and method. This is returned by the generated server, and usually + // shouldn't be returned by applications. Instead, applications should use + // NotFound or Unimplemented. + TwirpErrorCode["BadRoute"] = "bad_route"; + // AlreadyExists means an attempt to create an entity failed because one + // already exists. + TwirpErrorCode["AlreadyExists"] = "already_exists"; + // PermissionDenied indicates the caller does not have permission to execute + // the specified operation. It must not be used if the caller cannot be + // identified (Unauthenticated). + TwirpErrorCode["PermissionDenied"] = "permission_denied"; + // Unauthenticated indicates the request does not have valid authentication + // credentials for the operation. + TwirpErrorCode["Unauthenticated"] = "unauthenticated"; + // ResourceExhausted indicates some resource has been exhausted, perhaps a + // per-user quota, or perhaps the entire file system is out of space. + TwirpErrorCode["ResourceExhausted"] = "resource_exhausted"; + // FailedPrecondition indicates operation was rejected because the system is + // not in a state required for the operation's execution. For example, doing + // an rmdir operation on a directory that is non-empty, or on a non-directory + // object, or when having conflicting read-modify-write on the same resource. + TwirpErrorCode["FailedPrecondition"] = "failed_precondition"; + // Aborted indicates the operation was aborted, typically due to a concurrency + // issue like sequencer check failures, transaction aborts, etc. + TwirpErrorCode["Aborted"] = "aborted"; + // OutOfRange means operation was attempted past the valid range. For example, + // seeking or reading past end of a paginated collection. + // + // Unlike InvalidArgument, this error indicates a problem that may be fixed if + // the system state changes (i.e. adding more items to the collection). + // + // There is a fair bit of overlap between FailedPrecondition and OutOfRange. + // We recommend using OutOfRange (the more specific error) when it applies so + // that callers who are iterating through a space can easily look for an + // OutOfRange error to detect when they are done. + TwirpErrorCode["OutOfRange"] = "out_of_range"; + // Unimplemented indicates operation is not implemented or not + // supported/enabled in this service. + TwirpErrorCode["Unimplemented"] = "unimplemented"; + // Internal errors. When some invariants expected by the underlying system + // have been broken. In other words, something bad happened in the library or + // backend service. Do not confuse with HTTP Internal Server Error; an + // Internal error could also happen on the client code, i.e. when parsing a + // server response. + TwirpErrorCode["Internal"] = "internal"; + // Unavailable indicates the service is currently unavailable. This is a most + // likely a transient condition and may be corrected by retrying with a + // backoff. + TwirpErrorCode["Unavailable"] = "unavailable"; + // DataLoss indicates unrecoverable data loss or corruption. + TwirpErrorCode["DataLoss"] = "data_loss"; +})(TwirpErrorCode = exports.TwirpErrorCode || (exports.TwirpErrorCode = {})); +// ServerHTTPStatusFromErrorCode maps a Twirp error type into a similar HTTP +// response status. It is used by the Twirp server handler to set the HTTP +// response status code. Returns 0 if the ErrorCode is invalid. +function httpStatusFromErrorCode(code) { + switch (code) { + case TwirpErrorCode.Canceled: + return 408; // RequestTimeout + case TwirpErrorCode.Unknown: + return 500; // Internal Server Error + case TwirpErrorCode.InvalidArgument: + return 400; // BadRequest + case TwirpErrorCode.Malformed: + return 400; // BadRequest + case TwirpErrorCode.DeadlineExceeded: + return 408; // RequestTimeout + case TwirpErrorCode.NotFound: + return 404; // Not Found + case TwirpErrorCode.BadRoute: + return 404; // Not Found + case TwirpErrorCode.AlreadyExists: + return 409; // Conflict + case TwirpErrorCode.PermissionDenied: + return 403; // Forbidden + case TwirpErrorCode.Unauthenticated: + return 401; // Unauthorized + case TwirpErrorCode.ResourceExhausted: + return 429; // Too Many Requests + case TwirpErrorCode.FailedPrecondition: + return 412; // Precondition Failed + case TwirpErrorCode.Aborted: + return 409; // Conflict + case TwirpErrorCode.OutOfRange: + return 400; // Bad Request + case TwirpErrorCode.Unimplemented: + return 501; // Not Implemented + case TwirpErrorCode.Internal: + return 500; // Internal Server Error + case TwirpErrorCode.Unavailable: + return 503; // Service Unavailable + case TwirpErrorCode.DataLoss: + return 500; // Internal Server Error + default: + return 0; // Invalid! + } +} +exports.httpStatusFromErrorCode = httpStatusFromErrorCode; +// IsValidErrorCode returns true if is one of the valid predefined constants. +function isValidErrorCode(code) { + return httpStatusFromErrorCode(code) != 0; +} +exports.isValidErrorCode = isValidErrorCode; + + +/***/ }), + +/***/ 6748: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.Gateway = exports.Pattern = void 0; +const querystring_1 = __nccwpck_require__(3477); +const dotObject = __importStar(__nccwpck_require__(4365)); +const request_1 = __nccwpck_require__(8347); +const errors_1 = __nccwpck_require__(6647); +const http_client_1 = __nccwpck_require__(4091); +const server_1 = __nccwpck_require__(6604); +var Pattern; +(function (Pattern) { + Pattern["POST"] = "post"; + Pattern["GET"] = "get"; + Pattern["PATCH"] = "patch"; + Pattern["PUT"] = "put"; + Pattern["DELETE"] = "delete"; +})(Pattern = exports.Pattern || (exports.Pattern = {})); +/** + * The Gateway proxies http requests to Twirp Compliant + * handlers + */ +class Gateway { + constructor(routes) { + this.routes = routes; + } + /** + * Middleware that rewrite the current request + * to a Twirp compliant request + */ + twirpRewrite(prefix = "/twirp") { + return (req, resp, next) => { + this.rewrite(req, resp, prefix) + .then(() => next()) + .catch((e) => { + if (e instanceof errors_1.TwirpError) { + if (e.code !== errors_1.TwirpErrorCode.NotFound) { + server_1.writeError(resp, e); + } + else { + next(); + } + } + }); + }; + } + /** + * Rewrite an incoming request to a Twirp compliant request + * @param req + * @param resp + * @param prefix + */ + rewrite(req, resp, prefix = "/twirp") { + return __awaiter(this, void 0, void 0, function* () { + const [match, route] = this.matchRoute(req); + const body = yield this.prepareTwirpBody(req, match, route); + const twirpUrl = `${prefix}/${route.packageName}.${route.serviceName}/${route.methodName}`; + req.url = twirpUrl; + req.originalUrl = twirpUrl; + req.method = "POST"; + req.headers["content-type"] = "application/json"; + req.rawBody = Buffer.from(JSON.stringify(body)); + if (route.responseBodyKey) { + const endFn = resp.end.bind(resp); + resp.end = function (chunk) { + if (resp.statusCode === 200) { + endFn(`{ "${route.responseBodyKey}": ${chunk} }`); + } + else { + endFn(chunk); + } + }; + } + }); + } + /** + * Create a reverse proxy handler to + * proxy http requests to Twirp Compliant handlers + * @param httpClientOption + */ + reverseProxy(httpClientOption) { + const client = http_client_1.NodeHttpRPC(httpClientOption); + return (req, res) => __awaiter(this, void 0, void 0, function* () { + try { + const [match, route] = this.matchRoute(req); + const body = yield this.prepareTwirpBody(req, match, route); + const response = yield client.request(`${route.packageName}.${route.serviceName}`, route.methodName, "application/json", body); + res.statusCode = 200; + res.setHeader("content-type", "application/json"); + let jsonResponse; + if (route.responseBodyKey) { + jsonResponse = JSON.stringify({ [route.responseBodyKey]: response }); + } + else { + jsonResponse = JSON.stringify(response); + } + res.end(jsonResponse); + } + catch (e) { + server_1.writeError(res, e); + } + }); + } + /** + * Prepares twirp body requests using http.google.annotions + * compliant spec + * + * @param req + * @param match + * @param route + * @protected + */ + prepareTwirpBody(req, match, route) { + return __awaiter(this, void 0, void 0, function* () { + const _a = match.params, { query_string } = _a, params = __rest(_a, ["query_string"]); + let requestBody = Object.assign({}, params); + if (query_string && route.bodyKey !== "*") { + const queryParams = this.parseQueryString(query_string); + requestBody = Object.assign(Object.assign({}, queryParams), requestBody); + } + let body = {}; + if (route.bodyKey) { + const data = yield request_1.getRequestData(req); + try { + const jsonBody = JSON.parse(data.toString() || "{}"); + if (route.bodyKey === "*") { + body = jsonBody; + } + else { + body[route.bodyKey] = jsonBody; + } + } + catch (e) { + const msg = "the json request could not be decoded"; + throw new errors_1.TwirpError(errors_1.TwirpErrorCode.Malformed, msg).withCause(e, true); + } + } + return Object.assign(Object.assign({}, body), requestBody); + }); + } + /** + * Matches a route + * @param req + */ + matchRoute(req) { + var _a; + const httpMethod = (_a = req.method) === null || _a === void 0 ? void 0 : _a.toLowerCase(); + if (!httpMethod) { + throw new errors_1.BadRouteError(`method not allowed`, req.method || "", req.url || ""); + } + const routes = this.routes[httpMethod]; + for (const route of routes) { + const match = route.matcher(req.url || "/"); + if (match) { + return [match, route]; + } + } + throw new errors_1.NotFoundError(`url ${req.url} not found`); + } + /** + * Parse query string + * @param queryString + */ + parseQueryString(queryString) { + const queryParams = querystring_1.parse(queryString.replace("?", "")); + return dotObject.object(queryParams); + } +} +exports.Gateway = Gateway; + + +/***/ }), + +/***/ 4263: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.isHook = exports.chainHooks = void 0; +// ChainHooks creates a new ServerHook which chains the callbacks in +// each of the constituent hooks passed in. Each hook function will be +// called in the order of the ServerHooks values passed in. +// +// For the erroring hooks, RequestReceived and RequestRouted, any returned +// errors prevent processing by later hooks. +function chainHooks(...hooks) { + if (hooks.length === 0) { + return null; + } + if (hooks.length === 1) { + return hooks[0]; + } + const serverHook = { + requestReceived(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestReceived) { + continue; + } + yield hook.requestReceived(ctx); + } + }); + }, + requestPrepared(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestPrepared) { + continue; + } + console.warn("hook requestPrepared is deprecated and will be removed in the next release. " + + "Please use responsePrepared instead."); + yield hook.requestPrepared(ctx); + } + }); + }, + responsePrepared(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.responsePrepared) { + continue; + } + yield hook.responsePrepared(ctx); + } + }); + }, + requestSent(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestSent) { + continue; + } + console.warn("hook requestSent is deprecated and will be removed in the next release. " + + "Please use responseSent instead."); + yield hook.requestSent(ctx); + } + }); + }, + responseSent(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.responseSent) { + continue; + } + yield hook.responseSent(ctx); + } + }); + }, + requestRouted(ctx) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.requestRouted) { + continue; + } + yield hook.requestRouted(ctx); + } + }); + }, + error(ctx, err) { + return __awaiter(this, void 0, void 0, function* () { + for (const hook of hooks) { + if (!hook.error) { + continue; + } + yield hook.error(ctx, err); + } + }); + }, + }; + return serverHook; +} +exports.chainHooks = chainHooks; +function isHook(object) { + return ("requestReceived" in object || + "requestPrepared" in object || + "requestSent" in object || + "requestRouted" in object || + "responsePrepared" in object || + "responseSent" in object || + "error" in object); +} +exports.isHook = isHook; + + +/***/ }), + +/***/ 4091: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.FetchRPC = exports.wrapErrorResponseToTwirpError = exports.NodeHttpRPC = void 0; +const http = __importStar(__nccwpck_require__(3685)); +const https = __importStar(__nccwpck_require__(5687)); +const url_1 = __nccwpck_require__(7310); +const errors_1 = __nccwpck_require__(6647); +/** + * a node HTTP RPC implementation + * @param options + * @constructor + */ +const NodeHttpRPC = (options) => ({ + request(service, method, contentType, data) { + let client; + return new Promise((resolve, rejected) => { + const responseChunks = []; + const requestData = contentType === "application/protobuf" + ? Buffer.from(data) + : JSON.stringify(data); + const url = new url_1.URL(options.baseUrl); + const isHttps = url.protocol === "https:"; + if (isHttps) { + client = https; + } + else { + client = http; + } + const prefix = url.pathname !== "/" ? url.pathname : ""; + const req = client + .request(Object.assign(Object.assign({}, (options ? options : {})), { method: "POST", protocol: url.protocol, host: url.hostname, port: url.port ? url.port : isHttps ? 443 : 80, path: `${prefix}/${service}/${method}`, headers: Object.assign(Object.assign({}, (options.headers ? options.headers : {})), { "Content-Type": contentType, "Content-Length": contentType === "application/protobuf" + ? Buffer.byteLength(requestData) + : Buffer.from(requestData).byteLength }) }), (res) => { + res.on("data", (chunk) => responseChunks.push(chunk)); + res.on("end", () => { + const data = Buffer.concat(responseChunks); + if (res.statusCode != 200) { + rejected(wrapErrorResponseToTwirpError(data.toString())); + } + else { + if (contentType === "application/json") { + resolve(JSON.parse(data.toString())); + } + else { + resolve(data); + } + } + }); + res.on("error", (err) => { + rejected(err); + }); + }) + .on("error", (err) => { + rejected(err); + }); + req.end(requestData); + }); + }, +}); +exports.NodeHttpRPC = NodeHttpRPC; +function wrapErrorResponseToTwirpError(errorResponse) { + return errors_1.TwirpError.fromObject(JSON.parse(errorResponse)); +} +exports.wrapErrorResponseToTwirpError = wrapErrorResponseToTwirpError; +/** + * a browser fetch RPC implementation + */ +const FetchRPC = (options) => ({ + request(service, method, contentType, data) { + return __awaiter(this, void 0, void 0, function* () { + const headers = new Headers(options.headers); + headers.set("content-type", contentType); + const response = yield fetch(`${options.baseUrl}/${service}/${method}`, Object.assign(Object.assign({}, options), { method: "POST", headers, body: data instanceof Uint8Array ? data : JSON.stringify(data) })); + if (response.status === 200) { + if (contentType === "application/json") { + return yield response.json(); + } + return new Uint8Array(yield response.arrayBuffer()); + } + throw errors_1.TwirpError.fromObject(yield response.json()); + }); + }, +}); +exports.FetchRPC = FetchRPC; + + +/***/ }), + +/***/ 6465: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TwirpContentType = void 0; +__exportStar(__nccwpck_require__(1524), exports); +__exportStar(__nccwpck_require__(6604), exports); +__exportStar(__nccwpck_require__(8913), exports); +__exportStar(__nccwpck_require__(4263), exports); +__exportStar(__nccwpck_require__(6647), exports); +__exportStar(__nccwpck_require__(6748), exports); +__exportStar(__nccwpck_require__(4091), exports); +var request_1 = __nccwpck_require__(8347); +Object.defineProperty(exports, "TwirpContentType", ({ enumerable: true, get: function () { return request_1.TwirpContentType; } })); + + +/***/ }), + +/***/ 8913: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.chainInterceptors = void 0; +// chains multiple Interceptors into a single Interceptor. +// The first interceptor wraps the second one, and so on. +// Returns null if interceptors is empty. +function chainInterceptors(...interceptors) { + if (interceptors.length === 0) { + return; + } + if (interceptors.length === 1) { + return interceptors[0]; + } + const first = interceptors[0]; + return (ctx, request, handler) => __awaiter(this, void 0, void 0, function* () { + let next = handler; + for (let i = interceptors.length - 1; i > 0; i--) { + next = ((next) => (ctx, typedRequest) => { + return interceptors[i](ctx, typedRequest, next); + })(next); + } + return first(ctx, request, next); + }); +} +exports.chainInterceptors = chainInterceptors; + + +/***/ }), + +/***/ 8347: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.parseTwirpPath = exports.getRequestData = exports.validateRequest = exports.getContentType = exports.TwirpContentType = void 0; +const errors_1 = __nccwpck_require__(6647); +/** + * Supported Twirp Content-Type + */ +var TwirpContentType; +(function (TwirpContentType) { + TwirpContentType[TwirpContentType["Protobuf"] = 0] = "Protobuf"; + TwirpContentType[TwirpContentType["JSON"] = 1] = "JSON"; + TwirpContentType[TwirpContentType["Unknown"] = 2] = "Unknown"; +})(TwirpContentType = exports.TwirpContentType || (exports.TwirpContentType = {})); +/** + * Get supported content-type + * @param mimeType + */ +function getContentType(mimeType) { + switch (mimeType) { + case "application/protobuf": + return TwirpContentType.Protobuf; + case "application/json": + return TwirpContentType.JSON; + default: + return TwirpContentType.Unknown; + } +} +exports.getContentType = getContentType; +/** + * Validate a twirp request + * @param ctx + * @param request + * @param pathPrefix + */ +function validateRequest(ctx, request, pathPrefix) { + if (request.method !== "POST") { + const msg = `unsupported method ${request.method} (only POST is allowed)`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + const path = parseTwirpPath(request.url || ""); + if (path.pkgService !== + (ctx.packageName ? ctx.packageName + "." : "") + ctx.serviceName) { + const msg = `no handler for path ${request.url}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + if (path.prefix !== pathPrefix) { + const msg = `invalid path prefix ${path.prefix}, expected ${pathPrefix}, on path ${request.url}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + const mimeContentType = request.headers["content-type"] || ""; + if (ctx.contentType === TwirpContentType.Unknown) { + const msg = `unexpected Content-Type: ${request.headers["content-type"]}`; + throw new errors_1.BadRouteError(msg, request.method || "", request.url || ""); + } + return Object.assign(Object.assign({}, path), { mimeContentType, contentType: ctx.contentType }); +} +exports.validateRequest = validateRequest; +/** + * Get request data from the body + * @param req + */ +function getRequestData(req) { + return new Promise((resolve, reject) => { + const reqWithRawBody = req; + if (reqWithRawBody.rawBody instanceof Buffer) { + resolve(reqWithRawBody.rawBody); + return; + } + const chunks = []; + req.on("data", (chunk) => chunks.push(chunk)); + req.on("end", () => __awaiter(this, void 0, void 0, function* () { + const data = Buffer.concat(chunks); + resolve(data); + })); + req.on("error", (err) => { + if (req.aborted) { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.DeadlineExceeded, "failed to read request: deadline exceeded")); + } + else { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.Malformed, err.message).withCause(err)); + } + }); + req.on("close", () => { + reject(new errors_1.TwirpError(errors_1.TwirpErrorCode.Canceled, "failed to read request: context canceled")); + }); + }); +} +exports.getRequestData = getRequestData; +/** + * Parses twirp url path + * @param path + */ +function parseTwirpPath(path) { + const parts = path.split("/"); + if (parts.length < 2) { + return { + pkgService: "", + method: "", + prefix: "", + }; + } + return { + method: parts[parts.length - 1], + pkgService: parts[parts.length - 2], + prefix: parts.slice(0, parts.length - 2).join("/"), + }; +} +exports.parseTwirpPath = parseTwirpPath; + + +/***/ }), + +/***/ 6604: +/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.writeError = exports.TwirpServer = void 0; +const hooks_1 = __nccwpck_require__(4263); +const request_1 = __nccwpck_require__(8347); +const errors_1 = __nccwpck_require__(6647); +/** + * Runtime server implementation of a TwirpServer + */ +class TwirpServer { + constructor(options) { + this.pathPrefix = "/twirp"; + this.hooks = []; + this.interceptors = []; + this.packageName = options.packageName; + this.serviceName = options.serviceName; + this.methodList = options.methodList; + this.matchRoute = options.matchRoute; + this.service = options.service; + } + /** + * Returns the prefix for this server + */ + get prefix() { + return this.pathPrefix; + } + /** + * The http handler for twirp complaint endpoints + * @param options + */ + httpHandler(options) { + return (req, resp) => { + // setup prefix + if ((options === null || options === void 0 ? void 0 : options.prefix) !== undefined) { + this.withPrefix(options.prefix); + } + return this._httpHandler(req, resp); + }; + } + /** + * Adds interceptors or hooks to the request stack + * @param middlewares + */ + use(...middlewares) { + middlewares.forEach((middleware) => { + if (hooks_1.isHook(middleware)) { + this.hooks.push(middleware); + return this; + } + this.interceptors.push(middleware); + }); + return this; + } + /** + * Adds a prefix to the service url path + * @param prefix + */ + withPrefix(prefix) { + if (prefix === false) { + this.pathPrefix = ""; + } + else { + this.pathPrefix = prefix; + } + return this; + } + /** + * Returns the regex matching path for this twirp server + */ + matchingPath() { + const baseRegex = this.baseURI().replace(/\./g, "\\."); + return new RegExp(`${baseRegex}\/(${this.methodList.join("|")})`); + } + /** + * Returns the base URI for this twirp server + */ + baseURI() { + return `${this.pathPrefix}/${this.packageName ? this.packageName + "." : ""}${this.serviceName}`; + } + /** + * Create a twirp context + * @param req + * @param res + * @private + */ + createContext(req, res) { + return { + packageName: this.packageName, + serviceName: this.serviceName, + methodName: "", + contentType: request_1.getContentType(req.headers["content-type"]), + req: req, + res: res, + }; + } + /** + * Twrip server http handler implementation + * @param req + * @param resp + * @private + */ + _httpHandler(req, resp) { + return __awaiter(this, void 0, void 0, function* () { + const ctx = this.createContext(req, resp); + try { + yield this.invokeHook("requestReceived", ctx); + const { method, mimeContentType } = request_1.validateRequest(ctx, req, this.pathPrefix || ""); + const handler = this.matchRoute(method, { + onMatch: (ctx) => { + return this.invokeHook("requestRouted", ctx); + }, + onNotFound: () => { + const msg = `no handler for path ${req.url}`; + throw new errors_1.BadRouteError(msg, req.method || "", req.url || ""); + }, + }); + const body = yield request_1.getRequestData(req); + const response = yield handler(ctx, this.service, body, this.interceptors); + yield Promise.all([ + this.invokeHook("responsePrepared", ctx), + // keep backwards compatibility till next release + this.invokeHook("requestPrepared", ctx), + ]); + resp.statusCode = 200; + resp.setHeader("Content-Type", mimeContentType); + resp.end(response); + } + catch (e) { + yield this.invokeHook("error", ctx, mustBeTwirpError(e)); + if (!resp.headersSent) { + writeError(resp, e); + } + } + finally { + yield Promise.all([ + this.invokeHook("responseSent", ctx), + // keep backwards compatibility till next release + this.invokeHook("requestSent", ctx), + ]); + } + }); + } + /** + * Invoke a hook + * @param hookName + * @param ctx + * @param err + * @protected + */ + invokeHook(hookName, ctx, err) { + return __awaiter(this, void 0, void 0, function* () { + if (this.hooks.length === 0) { + return; + } + const chainedHooks = hooks_1.chainHooks(...this.hooks); + const hook = chainedHooks === null || chainedHooks === void 0 ? void 0 : chainedHooks[hookName]; + if (hook) { + yield hook(ctx, err || new errors_1.InternalServerError("internal server error")); + } + }); + } +} +exports.TwirpServer = TwirpServer; +/** + * Write http error response + * @param res + * @param error + */ +function writeError(res, error) { + const twirpError = mustBeTwirpError(error); + res.setHeader("Content-Type", "application/json"); + res.statusCode = errors_1.httpStatusFromErrorCode(twirpError.code); + res.end(twirpError.toJSON()); +} +exports.writeError = writeError; +/** + * Make sure that the error passed is a TwirpError + * otherwise it will wrap it into an InternalError + * @param err + */ +function mustBeTwirpError(err) { + if (err instanceof errors_1.TwirpError) { + return err; + } + return new errors_1.InternalServerErrorWith(err); +} + + /***/ }), /***/ 1773: @@ -67739,7 +76357,7 @@ class Request { } if (!extractBody) { - extractBody = (__nccwpck_require__(9990).extractBody) + extractBody = (__nccwpck_require__(1472).extractBody) } const [bodyStream, contentType] = extractBody(body) @@ -68866,7 +77484,7 @@ module.exports = Dispatcher /***/ }), -/***/ 9990: +/***/ 1472: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { "use strict"; @@ -71592,7 +80210,7 @@ const { } = __nccwpck_require__(2538) const { kState, kHeaders, kGuard, kRealm } = __nccwpck_require__(5861) const assert = __nccwpck_require__(9491) -const { safelyExtractBody } = __nccwpck_require__(9990) +const { safelyExtractBody } = __nccwpck_require__(1472) const { redirectStatusSet, nullBodyStatus, @@ -73706,7 +82324,7 @@ module.exports = { -const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(9990) +const { extractBody, mixinBody, cloneBody } = __nccwpck_require__(1472) const { Headers, fill: fillHeaders, HeadersList } = __nccwpck_require__(554) const { FinalizationRegistry } = __nccwpck_require__(6436)() const util = __nccwpck_require__(3983) @@ -74659,7 +83277,7 @@ module.exports = { Request, makeRequest } const { Headers, HeadersList, fill } = __nccwpck_require__(554) -const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(9990) +const { extractBody, cloneBody, mixinBody } = __nccwpck_require__(1472) const util = __nccwpck_require__(3983) const { kEnumerableProperty } = util const { @@ -82992,21 +91610,6 @@ module.exports = { } -/***/ }), - -/***/ 2155: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var v1 = __nccwpck_require__(8749); -var v4 = __nccwpck_require__(824); - -var uuid = v4; -uuid.v1 = v1; -uuid.v4 = v4; - -module.exports = uuid; - - /***/ }), /***/ 2707: @@ -83055,122 +91658,6 @@ module.exports = function nodeRNG() { }; -/***/ }), - -/***/ 8749: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -var rng = __nccwpck_require__(5859); -var bytesToUuid = __nccwpck_require__(2707); - -// **`v1()` - Generate time-based UUID** -// -// Inspired by https://github.com/LiosK/UUID.js -// and http://docs.python.org/library/uuid.html - -var _nodeId; -var _clockseq; - -// Previous uuid creation time -var _lastMSecs = 0; -var _lastNSecs = 0; - -// See https://github.com/uuidjs/uuid for API details -function v1(options, buf, offset) { - var i = buf && offset || 0; - var b = buf || []; - - options = options || {}; - var node = options.node || _nodeId; - var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; - - // node and clockseq need to be initialized to random values if they're not - // specified. We do this lazily to minimize issues related to insufficient - // system entropy. See #189 - if (node == null || clockseq == null) { - var seedBytes = rng(); - if (node == null) { - // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) - node = _nodeId = [ - seedBytes[0] | 0x01, - seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5] - ]; - } - if (clockseq == null) { - // Per 4.2.2, randomize (14 bit) clockseq - clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; - } - } - - // UUID timestamps are 100 nano-second units since the Gregorian epoch, - // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so - // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' - // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. - var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); - - // Per 4.2.1.2, use count of uuid's generated during the current clock - // cycle to simulate higher resolution clock - var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; - - // Time since last uuid creation (in msecs) - var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000; - - // Per 4.2.1.2, Bump clockseq on clock regression - if (dt < 0 && options.clockseq === undefined) { - clockseq = clockseq + 1 & 0x3fff; - } - - // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new - // time interval - if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { - nsecs = 0; - } - - // Per 4.2.1.2 Throw error if too many uuids are requested - if (nsecs >= 10000) { - throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec'); - } - - _lastMSecs = msecs; - _lastNSecs = nsecs; - _clockseq = clockseq; - - // Per 4.1.4 - Convert from unix epoch to Gregorian epoch - msecs += 12219292800000; - - // `time_low` - var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; - b[i++] = tl >>> 24 & 0xff; - b[i++] = tl >>> 16 & 0xff; - b[i++] = tl >>> 8 & 0xff; - b[i++] = tl & 0xff; - - // `time_mid` - var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff; - b[i++] = tmh >>> 8 & 0xff; - b[i++] = tmh & 0xff; - - // `time_high_and_version` - b[i++] = tmh >>> 24 & 0xf | 0x10; // include version - b[i++] = tmh >>> 16 & 0xff; - - // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) - b[i++] = clockseq >>> 8 | 0x80; - - // `clock_seq_low` - b[i++] = clockseq & 0xff; - - // `node` - for (var n = 0; n < 6; ++n) { - b[i + n] = node[n]; - } - - return buf ? buf : bytesToUuid(b); -} - -module.exports = v1; - - /***/ }), /***/ 824: @@ -94097,6 +102584,14 @@ function parseParams (str) { module.exports = parseParams +/***/ }), + +/***/ 9167: +/***/ ((module) => { + +"use strict"; +module.exports = JSON.parse('{"name":"@actions/cache","version":"4.0.0","preview":true,"description":"Actions cache lib","keywords":["github","actions","cache"],"homepage":"https://github.com/actions/toolkit/tree/main/packages/cache","license":"MIT","main":"lib/cache.js","types":"lib/cache.d.ts","directories":{"lib":"lib","test":"__tests__"},"files":["lib","!.DS_Store"],"publishConfig":{"access":"public"},"repository":{"type":"git","url":"git+https://github.com/actions/toolkit.git","directory":"packages/cache"},"scripts":{"audit-moderate":"npm install && npm audit --json --audit-level=moderate > audit.json","test":"echo \\"Error: run tests from root\\" && exit 1","tsc":"tsc"},"bugs":{"url":"https://github.com/actions/toolkit/issues"},"dependencies":{"@actions/core":"^1.11.1","@actions/exec":"^1.0.1","@actions/glob":"^0.1.0","@actions/http-client":"^2.1.1","@actions/io":"^1.0.1","@azure/abort-controller":"^1.1.0","@azure/ms-rest-js":"^2.6.0","@azure/storage-blob":"^12.13.0","@protobuf-ts/plugin":"^2.9.4","semver":"^6.3.1","twirp-ts":"^2.5.0"},"devDependencies":{"@types/semver":"^6.0.0","typescript":"^5.2.2"}}'); + /***/ }), /***/ 3765: diff --git a/package-lock.json b/package-lock.json index fb008d7..649bd4d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,7 +9,7 @@ "version": "5.0.0", "license": "MIT", "dependencies": { - "@actions/cache": "^3.2.4", + "@actions/cache": "^4.0.0", "@actions/core": "^1.10.0", "@actions/exec": "^1.1.0", "@actions/glob": "^0.4.0", @@ -47,11 +47,11 @@ } }, "node_modules/@actions/cache": { - "version": "3.2.4", - "resolved": "https://registry.npmjs.org/@actions/cache/-/cache-3.2.4.tgz", - "integrity": "sha512-RuHnwfcDagtX+37s0ZWy7clbOfnZ7AlDJQ7k/9rzt2W4Gnwde3fa/qjSjVuz4vLcLIpc7fUob27CMrqiWZytYA==", + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@actions/cache/-/cache-4.0.0.tgz", + "integrity": "sha512-WIuxjnZ44lNYtIS4fqSaYvF00hORdy3cSin+jx8xNgBVGWnNIAiCBHjlwusVQlcgExoQC9pHXGrDsZyZr7rCDQ==", "dependencies": { - "@actions/core": "^1.10.0", + "@actions/core": "^1.11.1", "@actions/exec": "^1.0.1", "@actions/glob": "^0.1.0", "@actions/http-client": "^2.1.1", @@ -59,8 +59,9 @@ "@azure/abort-controller": "^1.1.0", "@azure/ms-rest-js": "^2.6.0", "@azure/storage-blob": "^12.13.0", + "@protobuf-ts/plugin": "^2.9.4", "semver": "^6.3.1", - "uuid": "^3.3.3" + "twirp-ts": "^2.5.0" } }, "node_modules/@actions/cache/node_modules/@actions/glob": { @@ -81,20 +82,12 @@ } }, "node_modules/@actions/core": { - "version": "1.10.1", - "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.1.tgz", - "integrity": "sha512-3lBR9EDAY+iYIpTnTIXmWcNbX3T2kCkAEQGIQx4NVQ0575nk2k3GRZDTPQG+vVtS2izSLmINlxXf0uLtnrTP+g==", + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.11.1.tgz", + "integrity": "sha512-hXJCSrkwfA46Vd9Z3q4cpEpHB1rL5NG04+/rbqW9d3+CSvtB1tYe8UTpAlixa1vj0m/ULglfEK2UKxMGxCxv5A==", "dependencies": { - "@actions/http-client": "^2.0.1", - "uuid": "^8.3.2" - } - }, - "node_modules/@actions/core/node_modules/uuid": { - "version": "8.3.2", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", - "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", - "bin": { - "uuid": "dist/bin/uuid" + "@actions/exec": "^1.1.1", + "@actions/http-client": "^2.0.1" } }, "node_modules/@actions/exec": { @@ -1565,6 +1558,76 @@ "node": ">=8.0.0" } }, + "node_modules/@protobuf-ts/plugin": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin/-/plugin-2.9.4.tgz", + "integrity": "sha512-Db5Laq5T3mc6ERZvhIhkj1rn57/p8gbWiCKxQWbZBBl20wMuqKoHbRw4tuD7FyXi+IkwTToaNVXymv5CY3E8Rw==", + "dependencies": { + "@protobuf-ts/plugin-framework": "^2.9.4", + "@protobuf-ts/protoc": "^2.9.4", + "@protobuf-ts/runtime": "^2.9.4", + "@protobuf-ts/runtime-rpc": "^2.9.4", + "typescript": "^3.9" + }, + "bin": { + "protoc-gen-dump": "bin/protoc-gen-dump", + "protoc-gen-ts": "bin/protoc-gen-ts" + } + }, + "node_modules/@protobuf-ts/plugin-framework": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/plugin-framework/-/plugin-framework-2.9.4.tgz", + "integrity": "sha512-9nuX1kjdMliv+Pes8dQCKyVhjKgNNfwxVHg+tx3fLXSfZZRcUHMc1PMwB9/vTvc6gBKt9QGz5ERqSqZc0++E9A==", + "dependencies": { + "@protobuf-ts/runtime": "^2.9.4", + "typescript": "^3.9" + } + }, + "node_modules/@protobuf-ts/plugin-framework/node_modules/typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@protobuf-ts/plugin/node_modules/typescript": { + "version": "3.9.10", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.10.tgz", + "integrity": "sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=4.2.0" + } + }, + "node_modules/@protobuf-ts/protoc": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/protoc/-/protoc-2.9.4.tgz", + "integrity": "sha512-hQX+nOhFtrA+YdAXsXEDrLoGJqXHpgv4+BueYF0S9hy/Jq0VRTVlJS1Etmf4qlMt/WdigEes5LOd/LDzui4GIQ==", + "bin": { + "protoc": "protoc.js" + } + }, + "node_modules/@protobuf-ts/runtime": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.9.4.tgz", + "integrity": "sha512-vHRFWtJJB/SiogWDF0ypoKfRIZ41Kq+G9cEFj6Qm1eQaAhJ1LDFvgZ7Ja4tb3iLOQhz0PaoPnnOijF1qmEqTxg==" + }, + "node_modules/@protobuf-ts/runtime-rpc": { + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime-rpc/-/runtime-rpc-2.9.4.tgz", + "integrity": "sha512-y9L9JgnZxXFqH5vD4d7j9duWvIJ7AShyBRoNKJGhu9Q27qIbchfzli66H9RvrQNIFk5ER7z1Twe059WZGqERcA==", + "dependencies": { + "@protobuf-ts/runtime": "^2.9.4" + } + }, "node_modules/@sinclair/typebox": { "version": "0.27.8", "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", @@ -2289,6 +2352,15 @@ "node": ">=6" } }, + "node_modules/camel-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", + "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", + "dependencies": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, "node_modules/camelcase": { "version": "5.3.1", "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", @@ -2423,6 +2495,14 @@ "node": ">= 0.8" } }, + "node_modules/commander": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.1.tgz", + "integrity": "sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==", + "engines": { + "node": ">= 6" + } + }, "node_modules/concat-map": { "version": "0.0.1", "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", @@ -2565,6 +2645,18 @@ "node": ">=6.0.0" } }, + "node_modules/dot-object": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/dot-object/-/dot-object-2.1.5.tgz", + "integrity": "sha512-xHF8EP4XH/Ba9fvAF2LDd5O3IITVolerVV6xvkxoM8zlGEiCUrggpAnHyOoKJKCrhvPcGATFAUwIujj7bRG5UA==", + "dependencies": { + "commander": "^6.1.0", + "glob": "^7.1.6" + }, + "bin": { + "dot-object": "bin/dot-object" + } + }, "node_modules/electron-to-chromium": { "version": "1.4.587", "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.587.tgz", @@ -3127,8 +3219,7 @@ "node_modules/fs.realpath": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", - "dev": true + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==" }, "node_modules/fsevents": { "version": "2.3.3", @@ -3196,7 +3287,6 @@ "version": "7.2.3", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", - "dev": true, "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", @@ -3364,7 +3454,6 @@ "version": "1.0.6", "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", - "dev": true, "dependencies": { "once": "^1.3.0", "wrappy": "1" @@ -3373,8 +3462,7 @@ "node_modules/inherits": { "version": "2.0.4", "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "dev": true + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" }, "node_modules/is-arrayish": { "version": "0.2.1", @@ -4217,6 +4305,11 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" + }, "node_modules/lodash.memoize": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", @@ -4229,6 +4322,14 @@ "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", "dev": true }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "dependencies": { + "tslib": "^2.0.3" + } + }, "node_modules/lru-cache": { "version": "5.1.1", "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", @@ -4353,6 +4454,15 @@ "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", "dev": true }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, "node_modules/node-fetch": { "version": "2.7.0", "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", @@ -4409,7 +4519,6 @@ "version": "1.4.0", "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", - "dev": true, "dependencies": { "wrappy": "1" } @@ -4515,6 +4624,15 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/pascal-case": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", + "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, "node_modules/path-exists": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", @@ -4528,7 +4646,6 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", - "dev": true, "engines": { "node": ">=0.10.0" } @@ -4548,6 +4665,11 @@ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, + "node_modules/path-to-regexp": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", + "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==" + }, "node_modules/path-type": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", @@ -4661,7 +4783,6 @@ "version": "2.8.8", "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz", "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==", - "dev": true, "bin": { "prettier": "bin-prettier.js" }, @@ -5206,6 +5327,15 @@ } } }, + "node_modules/ts-poet": { + "version": "4.15.0", + "resolved": "https://registry.npmjs.org/ts-poet/-/ts-poet-4.15.0.tgz", + "integrity": "sha512-sLLR8yQBvHzi9d4R1F4pd+AzQxBfzOSSjfxiJxQhkUoH5bL7RsAC6wgvtVUQdGqiCsyS9rT6/8X2FI7ipdir5g==", + "dependencies": { + "lodash": "^4.17.15", + "prettier": "^2.5.1" + } + }, "node_modules/tslib": { "version": "2.6.2", "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", @@ -5240,6 +5370,34 @@ "node": ">=0.6.11 <=0.7.0 || >=0.7.3" } }, + "node_modules/twirp-ts": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/twirp-ts/-/twirp-ts-2.5.0.tgz", + "integrity": "sha512-JTKIK5Pf/+3qCrmYDFlqcPPUx+ohEWKBaZy8GL8TmvV2VvC0SXVyNYILO39+GCRbqnuP6hBIF+BVr8ZxRz+6fw==", + "dependencies": { + "@protobuf-ts/plugin-framework": "^2.0.7", + "camel-case": "^4.1.2", + "dot-object": "^2.1.4", + "path-to-regexp": "^6.2.0", + "ts-poet": "^4.5.0", + "yaml": "^1.10.2" + }, + "bin": { + "protoc-gen-twirp_ts": "protoc-gen-twirp_ts" + }, + "peerDependencies": { + "@protobuf-ts/plugin": "^2.5.0", + "ts-proto": "^1.81.3" + }, + "peerDependenciesMeta": { + "@protobuf-ts/plugin": { + "optional": true + }, + "ts-proto": { + "optional": true + } + } + }, "node_modules/type-check": { "version": "0.4.0", "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", @@ -5422,8 +5580,7 @@ "node_modules/wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", - "dev": true + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" }, "node_modules/write-file-atomic": { "version": "4.0.2", @@ -5473,6 +5630,14 @@ "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", "dev": true }, + "node_modules/yaml": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz", + "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==", + "engines": { + "node": ">= 6" + } + }, "node_modules/yargs": { "version": "17.7.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", diff --git a/package.json b/package.json index f7c3ef4..c9dcfec 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ "author": "GitHub", "license": "MIT", "dependencies": { - "@actions/cache": "^3.2.4", + "@actions/cache": "^4.0.0", "@actions/core": "^1.10.0", "@actions/exec": "^1.1.0", "@actions/glob": "^0.4.0",