Upload 1904 files

.cache/replit/__replit_disk_meta.json

@@ -0,0 +1 @@
+{"nonce":4509958721781262117,"last_updated":{"seconds":1699143476,"nanos":34568000}}

.cache/replit/modules/replit_v5-20240209-9e3a339.res

@@ -0,0 +1 @@
+{"type":"resolve","resolvedModuleId":"replit:v5-20240209-9e3a339","inputHash":"","resolutionPath":["replit","replit:v1-20231211-d5ddcff","replit:v2-20240117-0bd73cd","replit:v3-20240123-c72e35a","replit:v4-20240206-fdbd396","replit:v5-20240209-9e3a339"],"error":"","Changed":true}

.cache/replit/nix/env.json

@@ -0,0 +1 @@
+{"entries":{"replit.nix":{"env":{"AR":"ar","AS":"as","CC":"gcc","CONFIG_SHELL":"/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin/bash","CXX":"g++","HOST_PATH":"/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/bin:/nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2/bin:/nix/store/zdcnqq55qi214j46zgw2qa1jp4dpdf2m-yarn-1.22.19/bin:/nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0/bin:/nix/store/a7gvj343m05j2s32xcnwr35v31ynlypr-coreutils-9.1/bin:/nix/store/mydc6f4k2z73xlcz7ilif3v2lcaiqvza-findutils-4.9.0/bin:/nix/store/j9p3g8472iijd50vhdprx0nmk2fqn5gv-diffutils-3.8/bin:/nix/store/89zs7rms6x00xfq4dq6m7mjnhkr8a6r4-gnused-4.8/bin:/nix/store/86bp03jkmsl6f92w0yzg4s59g5mhxwmy-gnugrep-3.7/bin:/nix/store/hwcdqw4jrjnd37wxqgsd47hd0j8bnj09-gawk-5.1.1/bin:/nix/store/cfbhw8r8ags41vwqaz47r583d0p4h4a1-gnutar-1.34/bin:/nix/store/p3m1ndl1lapwrlh698bnb5lvvxh67378-gzip-1.12/bin:/nix/store/a8mhcagrsly7c7mpjrpsnaahk4aax056-bzip2-1.0.8-bin/bin:/nix/store/mblgz65m3zv9x548a3d5m96fj2pbwr09-gnumake-4.3/bin:/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin:/nix/store/v7ljksji50mg3w61dykaa3n3y79n6nil-patch-2.7.6/bin:/nix/store/zlcnmqq14jz5x9439jf937mvayyl63da-xz-5.2.7-bin/bin:/nix/store/y6aj732zm9m87c82fpvf103a1xb22blp-file-5.43/bin","LD":"ld","LD_LIBRARY_PATH":"/nix/store/q4hrphx851xvkcnyyvqqyf1yjgmkmiar-mesa-22.2.3-drivers/lib:/nix/store/cxhib72pd7n3fzl1yh6lrm4q16l42kws-libglvnd-1.5.0/lib:/nix/store/bvihhgw8bh6cqqlj0d4s8cvmm4mqmzfc-pulseaudio-16.1/lib","LIBGL_DRIVERS_PATH":"/nix/store/q4hrphx851xvkcnyyvqqyf1yjgmkmiar-mesa-22.2.3-drivers/lib/dri","LOCALE_ARCHIVE":"/usr/lib/locale/locale-archive","NIX_BINTOOLS":"/nix/store/1d6ian3r8kdzspw8hacjhl3xkp40g1lj-binutils-wrapper-2.39","NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu":"1","NIX_BUILD_CORES":"1","NIX_BUILD_TOP":"/tmp","NIX_CC":"/nix/store/dq0xwmsk1g0i2ayg6pb7y87na2knzylh-gcc-wrapper-11.3.0","NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu":"1","NIX_CFLAGS_COMPILE":" -frandom-seed=1i84iccb7a -isystem /nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/include -isystem /nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/include","NIX_ENFORCE_NO_NATIVE":"1","NIX_HARDENING_ENABLE":"fortify stackprotector pic strictoverflow format relro bindnow","NIX_INDENT_MAKE":"1","NIX_LDFLAGS":"-rpath /nix/store/1i84iccb7aypxiyzk5pgbni88566v3ly-nix-shell/lib64 -rpath /nix/store/1i84iccb7aypxiyzk5pgbni88566v3ly-nix-shell/lib ","NIX_STORE":"/nix/store","NM":"nm","NODE_PATH":"/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/lib/node_modules:/nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2/lib/node_modules:/nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0/lib/node_modules","OBJCOPY":"objcopy","OBJDUMP":"objdump","PATH":"/nix/store/bap4d0lpcrhpwmpb8ayjcgkmvfj62lnq-bash-interactive-5.1-p16/bin:/nix/store/pr5n59mb4jzmfx6kanwxly0l07p861fg-patchelf-0.15.0/bin:/nix/store/dq0xwmsk1g0i2ayg6pb7y87na2knzylh-gcc-wrapper-11.3.0/bin:/nix/store/1gf2flfqnpqbr1b4p4qz2f72y42bs56r-gcc-11.3.0/bin:/nix/store/57xv61c5zi8pphjbcwxxjlgc34p61ic9-glibc-2.35-163-bin/bin:/nix/store/a7gvj343m05j2s32xcnwr35v31ynlypr-coreutils-9.1/bin:/nix/store/1d6ian3r8kdzspw8hacjhl3xkp40g1lj-binutils-wrapper-2.39/bin:/nix/store/039g378vc3pc3dvi9dzdlrd0i4q93qwf-binutils-2.39/bin:/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/bin:/nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2/bin:/nix/store/zdcnqq55qi214j46zgw2qa1jp4dpdf2m-yarn-1.22.19/bin:/nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0/bin:/nix/store/a7gvj343m05j2s32xcnwr35v31ynlypr-coreutils-9.1/bin:/nix/store/mydc6f4k2z73xlcz7ilif3v2lcaiqvza-findutils-4.9.0/bin:/nix/store/j9p3g8472iijd50vhdprx0nmk2fqn5gv-diffutils-3.8/bin:/nix/store/89zs7rms6x00xfq4dq6m7mjnhkr8a6r4-gnused-4.8/bin:/nix/store/86bp03jkmsl6f92w0yzg4s59g5mhxwmy-gnugrep-3.7/bin:/nix/store/hwcdqw4jrjnd37wxqgsd47hd0j8bnj09-gawk-5.1.1/bin:/nix/store/cfbhw8r8ags41vwqaz47r583d0p4h4a1-gnutar-1.34/bin:/nix/store/p3m1ndl1lapwrlh698bnb5lvvxh67378-gzip-1.12/bin:/nix/store/a8mhcagrsly7c7mpjrpsnaahk4aax056-bzip2-1.0.8-bin/bin:/nix/store/mblgz65m3zv9x548a3d5m96fj2pbwr09-gnumake-4.3/bin:/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin:/nix/store/v7ljksji50mg3w61dykaa3n3y79n6nil-patch-2.7.6/bin:/nix/store/zlcnmqq14jz5x9439jf937mvayyl63da-xz-5.2.7-bin/bin:/nix/store/y6aj732zm9m87c82fpvf103a1xb22blp-file-5.43/bin","RANLIB":"ranlib","READELF":"readelf","REPLIT_LD_LIBRARY_PATH":"/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1/lib:/nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2/lib:/nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0/lib","SIZE":"size","SOURCE_DATE_EPOCH":"315532800","STRINGS":"strings","STRIP":"strip","XDG_DATA_DIRS":"/nix/store/pr5n59mb4jzmfx6kanwxly0l07p861fg-patchelf-0.15.0/share","_":"/nix/store/a7gvj343m05j2s32xcnwr35v31ynlypr-coreutils-9.1/bin/env","__EGL_VENDOR_LIBRARY_FILENAMES":"/nix/store/q4hrphx851xvkcnyyvqqyf1yjgmkmiar-mesa-22.2.3-drivers/share/glvnd/egl_vendor.d/50_mesa.json","__ETC_PROFILE_SOURCED":"1","buildInputs":"/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1 /nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2 /nix/store/zdcnqq55qi214j46zgw2qa1jp4dpdf2m-yarn-1.22.19 /nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0","buildPhase":"echo \"------------------------------------------------------------\" \u003e\u003e$out\necho \" WARNING: the existence of this path is not guaranteed.\" \u003e\u003e$out\necho \" It is an internal implementation detail for pkgs.mkShell.\"   \u003e\u003e$out\necho \"------------------------------------------------------------\" \u003e\u003e$out\necho \u003e\u003e $out\n# Record all build inputs as runtime dependencies\nexport \u003e\u003e $out\n","builder":"/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin/bash","cmakeFlags":"","configureFlags":"","depsBuildBuild":"","depsBuildBuildPropagated":"","depsBuildTarget":"","depsBuildTargetPropagated":"","depsHostHost":"","depsHostHostPropagated":"","depsTargetTarget":"","depsTargetTargetPropagated":"","doCheck":"","doInstallCheck":"","mesonFlags":"","name":"nix-shell","nativeBuildInputs":"","out":"/nix/store/1i84iccb7aypxiyzk5pgbni88566v3ly-nix-shell","outputs":"out","patches":"","phases":"buildPhase","propagatedBuildInputs":"","propagatedNativeBuildInputs":"","shell":"/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin/bash","shellHook":"","stdenv":"/nix/store/kmfaajdpyyyg319vfqni5jm9wkxjmf73-stdenv-linux","strictDeps":"","system":"x86_64-linux"},"dependencies":[{"path":"replit.nix","mod_time":"2024-02-22T20:14:14.504363299Z"}],"closure":["/nix/store/34xlpp3j3vy7ksn09zh44f1c04w77khf-libunistring-1.0","/nix/store/5mh5019jigj0k14rdnjam1xwk5avn1id-libidn2-2.3.2","/nix/store/4nlgxhb09sdr51nc9hdm8az5b08vzkgx-glibc-2.35-163","/nix/store/026hln0aq1hyshaxsdvhg0kmcm6yf45r-zlib-1.2.13","/nix/store/mdck89nsfisflwjv6xv8ydj7dj0sj2pn-gcc-11.3.0-lib","/nix/store/039g378vc3pc3dvi9dzdlrd0i4q93qwf-binutils-2.39","/nix/store/9ad850yxw6jfvf3l3dbvp8dh2a3g4j71-libgpg-error-1.45","/nix/store/073j1x6mc31pz9hff2a1nb423kmkl3ii-libassuan-2.5.5","/nix/store/09gxmx43bc0snqc2hf094hnxpx2bb4hh-libXdmcp-1.1.3","/nix/store/57xv61c5zi8pphjbcwxxjlgc34p61ic9-glibc-2.35-163-bin","/nix/store/09gyxf17hs4hkpgnbj1kdz8xk5c3w4mm-getent-glibc-2.35-163","/nix/store/4mxnw95jcm5a27qk60z7yc0gvxp42b9a-openssl-3.0.7","/nix/store/75dl24qd9yvigjkndfqjkhlbwq8i2q87-libcbor-0.9.0","/nix/store/cr5fmwri3601s7724ayjvckhsg6cz4rv-attr-2.5.1","/nix/store/7q41sbf04qcwv75j5bxis6pfjnmshy44-acl-2.3.1","/nix/store/w10in9diaqrcqqxi5lg20n3q2jfpk6pq-zstd-1.5.2","/nix/store/w3sdhqiazzp4iy40wc2g85mv0grg1cx0-xz-5.2.7","/nix/store/86yrrihrf5ghfvrh3j087zhpc9iajsmh-kmod-30-lib","/nix/store/9izprbjfnlk2dn9sqp9af9nci6zncx2l-kexec-tools-2.0.25","/nix/store/lgdq362bvrzc4bg0cb8mj38rsjcmzxsf-gmp-with-cxx-stage4-6.2.1","/nix/store/a7gvj343m05j2s32xcnwr35v31ynlypr-coreutils-9.1","/nix/store/acvafmp652dj67f4g3sdx68n2mg1afz4-util-linux-minimal-2.38.1-lib","/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16","/nix/store/b09kqza5nw7y2jpvb6q4dz9hixrm0ipk-db-4.8.30","/nix/store/mhcgwcc7r208pnwv5j26j58iqvl1yvqj-audit-2.8.5","/nix/store/xf0ssp8s6xjz710q33hspj5dphqhmmc1-libxcrypt-4.4.30","/nix/store/hk0qw5ynzy1h7w4vn4bg6hwirf2a2y56-linux-pam-1.5.2","/nix/store/c7klanhckqpsvv4x2izcyzvfb8vazy4s-shadow-4.11.1","/nix/store/jv63bkng8b3y1zw0qsjrpwz2gsibll82-libcap-ng-0.8.3","/nix/store/asixagjq1jfkbmgi1600j23v394sr58a-util-linux-minimal-2.38.1-bin","/nix/store/1i5ah27gxx3a3fyjyydfwwzqq8ni33i8-ncurses-6.3-p20220507","/nix/store/5gkbi9cfq8hddrfzzjdpvhrw8fsp5xsl-readline-8.1p2","/nix/store/bap4d0lpcrhpwmpb8ayjcgkmvfj62lnq-bash-interactive-5.1-p16","/nix/store/c8byvs0rj8vg5cpm5mswcg5dvp7d5ir7-libseccomp-2.5.4-lib","/nix/store/inhqw7zx59hxa0r9am0kw3ip88hpbbrw-kmod-30","/nix/store/jijvvmbza698qa6yjgr1ndgdgyryvq1i-libcap-2.66-lib","/nix/store/ysl6qj5r7nn63b16954dhk7x47r5yq7i-bzip2-1.0.8","/nix/store/a8mhcagrsly7c7mpjrpsnaahk4aax056-bzip2-1.0.8-bin","/nix/store/1dgws25664p544znpc6f1nh9xmjf4ykc-pcre-8.45","/nix/store/86bp03jkmsl6f92w0yzg4s59g5mhxwmy-gnugrep-3.7","/nix/store/mb0pcxkmrg0f6k0zaywlnvpk9q3j5ans-zstd-1.5.2-bin","/nix/store/p3m1ndl1lapwrlh698bnb5lvvxh67378-gzip-1.12","/nix/store/zlcnmqq14jz5x9439jf937mvayyl63da-xz-5.2.7-bin","/nix/store/qmp028x2h8k1i032w88h2lhbylfpi1wj-kbd-2.5.1","/nix/store/adnxnv29s3nnrxrv19z5jnqzww0jd1aa-systemd-minimal-251.7","/nix/store/dfxf2gqizhb1gk1p3qv7jgl9gnlqdaf5-pcsclite-1.9.5","/nix/store/0g989zr25nvqrxdbxbwpzdfc1r6f7m9z-libfido2-1.12.0","/nix/store/974czghvkyg72giyf1lcy76f5zl6dgkh-libogg-1.3.5","/nix/store/0ijjp3ff50ahanz7190syxavgjslbb1r-flac-1.4.2","/nix/store/0y971q54v6jm9ss243xhl4y0gnlsm9c8-zlib-1.2.13-dev","/nix/store/36xp94y7564gc5p6miyddg6xn9bi6pp0-libuv-1.44.2","/nix/store/r3x96j3kmcs8dv4l02rrjmbhm535jycy-icu4c-72.1","/nix/store/7xqm5wfm4djpspmdgj36ijnql31id8xg-icu4c-72.1-dev","/nix/store/1zlrx8g7xs6ar0ggca4h3p6hmapq2p2h-perl-5.36.0","/nix/store/fq47cv26nb87hwz2678r6i8ym5b57lwf-openssl-3.0.7-bin","/nix/store/f95kxwhnr2bazy7nl6wzwjiak02dlp9v-openssl-3.0.7-dev","/nix/store/2217a7zw3rdwx96xn9kcjwlcxkhn9qf8-gdbm-1.23","/nix/store/4lkjvagv0bqq58qpysfabw66rqrbddgb-expat-2.5.0","/nix/store/5aspvhbacf0knl5yyf0x3cs25inxh016-readline-6.3p08","/nix/store/i16lgq16av602nfyws3ps8dd9yj36dwh-tzdata-2022f","/nix/store/jpj9lx0p2h1vs3gkzj8jh350113bsm84-sqlite-3.39.4","/nix/store/pplp2i09gc4k67a4aayr78a4c04jbqxa-mailcap-2.1.53","/nix/store/xghl0l2f6byzqvy06ana2y4isqwa7blw-libffi-3.4.4","/nix/store/zdba9frlxj2ba8ca095win3nphsiiqhb-python3-3.10.8","/nix/store/0l5yh0rdzibk8arj9c8gzy1570jkc3vf-nodejs-16.18.1","/nix/store/46fw6pyn1zs9y0fwfdbgn4363ill17g9-elfutils-0.188","/nix/store/0snlk51mis3zacmva8lpkd462ck831wh-libbpf-1.0.1","/nix/store/i38jcxrwa4fxk2b7acxircpi399kyixw-linux-headers-6.0","/nix/store/4pqv2mwdn88h7xvsm7a5zplrd8sxzvw0-glibc-2.35-163-dev","/nix/store/a1ad8qiqqb9fpg5a9rhlkm44s02sr61p-expand-response-params","/nix/store/1d6ian3r8kdzspw8hacjhl3xkp40g1lj-binutils-wrapper-2.39","/nix/store/1gf2flfqnpqbr1b4p4qz2f72y42bs56r-gcc-11.3.0","/nix/store/1i5y55x4b4m9qkx5dqbmr1r6bvrqbanw-multiple-outputs.sh","/nix/store/6z3agp6jqqdrnrdlsgzbdgw56z8azgr9-npth-1.6","/nix/store/fbd2zvpx1iyisqmq5hn3hdnqs03ycz57-libgcrypt-1.10.1","/nix/store/1nwdvd4bkac2g3a3sd84qbfi4mf07l3y-gnupg-2.3.7","/nix/store/cjdm2inq3madwqpnnddi59vv5yd89m52-pcre2-10.40","/nix/store/ii8xgfqglbvvaiv4isqpy0s7lhqgxrmy-libselinux-3.3","/nix/store/2k366jrbsra97gjfxwvrhvixjfxdach5-glib-2.74.1","/nix/store/2rgwrp4zwia0ayhhxzw000cnjvr51pxa-lz4-1.9.4","/nix/store/2w5ssck8y4kfcpj2argg0kmaw32ii275-dconf-0.40.0-lib","/nix/store/3s1pgzk4acxn7rl6l8z2390w70426yb2-lvm2-2.03.16-lib","/nix/store/59jmzisg8fkm9c125fw384dqq1np602l-move-docs.sh","/nix/store/5bi6hkakf48r8j1nhmhmgbqpij5ka597-sbc-1.4","/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh","/nix/store/94gdvbv86cifg62hblk0397n5x7pb03l-libtool-2.4.7-lib","/nix/store/dj1c4rx8ly8kw6i614plql6vm8595pjq-libasyncns-0.8","/nix/store/h3h96j064p5kdjyw48j80005y99j5rcg-soxr-0.1.3","/nix/store/904r2fg24xhnxq7511lqnjy06si0h5j9-libapparmor-3.1.2","/nix/store/cfbhw8r8ags41vwqaz47r583d0p4h4a1-gnutar-1.34","/nix/store/ayr7k5an06pnhpgw2a7zdhvnqzb3chsh-json-c-0.16","/nix/store/g1l4jwmlmab794rb5b3ch3xf0d1168mq-cryptsetup-2.5.0","/nix/store/cph87856yzakak001w00ck5n5cdajl19-libevent-2.1.12","/nix/store/ijz81p08bp812q2bvv77lz9qpfzncibd-gmp-with-cxx-6.2.1","/nix/store/raz5jjjszg123qlmx07dv0w5zjqf2x3y-nettle-3.8.1","/nix/store/gigp6hvw7vn3576dipp0wlkmpp8szs85-unbound-1.17.0-lib","/nix/store/vzrbz3lvmiziy3i79rzmk01wfprhwjh0-libtasn1-4.19.0","/nix/store/h6hww2m19vbc93n6511zvhd810cql278-p11-kit-0.24.1","/nix/store/nsk5b96rl1imwvwpqnkxmqkh0bk9m2dm-dns-root-data-2019-01-11","/nix/store/mq9jfv5yzjr626nszc429pkbg6qc22wa-gnutls-3.7.8","/nix/store/jbvsz76svifygzvvvpi3s6q1zd85b009-libmicrohttpd-0.9.71","/nix/store/cdrs17s1dbdzv0giqvm2lzvxkwrwl6k2-libpcap-1.10.1","/nix/store/idfq8lh60m316bs1958bs1lxffcjxbjm-libnfnetlink-1.0.2","/nix/store/np5midk4wz7xpmwcp4h6ina1jgxwn92h-libmnl-1.0.5","/nix/store/d24wnh2mgf5v70pb7y1yqhx9vjxzdii7-libnetfilter_conntrack-1.0.9","/nix/store/iicq4q8n5adnylc3lixlsmfkznx8h3cr-libnftnl-1.2.4","/nix/store/lq1i7dylhdza29yfpjgvkzfrbpjm4w00-iptables-1.8.8","/nix/store/9iy1ng7h1l6jdmjk157jra8n4hkrfdj1-brotli-1.0.9-lib","/nix/store/qz400bwshaqikj5s2qyvh0c9qffgmqik-nghttp2-1.49.0-lib","/nix/store/816qwr4xy058451rbxr0ccyh1v1akhb6-keyutils-1.6.3-lib","/nix/store/r7gl900my2fw6k33nxh2r7rzv8nv0s25-libkrb5-1.20","/nix/store/vqq9s0d6fw6kqf3sr5nrzqbys9rhygqd-libssh2-1.10.0","/nix/store/rirzp6ijbcwnxlf0b2n286n587r3z9jw-curl-7.86.0","/nix/store/mbyb9f7k47bisn5y2ga3srda4sasi8yi-tpm2-tss-3.2.0","/nix/store/hlf86vmyh14scxwann44fy3azvc6njaj-systemd-251.7","/nix/store/vhw80flmxy6d7xpqs1h56k629xsmmasz-gfortran-11.3.0-lib","/nix/store/lgx9ccic6miz2wrbjhyw6gzbz12rf0pj-fftw-single-3.3.10","/nix/store/kdd3flb0zgiy336sja4ic8lmrpdl5xr7-speexdsp-1.2.1","/nix/store/g6k7s2waqvz6b4bsj4v3ypb9kf12bhd8-alsa-ucm-conf-1.2.7.1","/nix/store/rrwf2b4dhpigs3mvc6z3nsnlzm0qccmq-alsa-topology-conf-1.2.5.1","/nix/store/l3m7axrj699nx4j024sb0dw0215alsd1-alsa-lib-1.2.7.2","/nix/store/k3k6jmzxfjq1s3la01ffpjv2blqd66lk-libvorbis-1.3.7","/nix/store/kzkg5g476xkdh2xwd27ylmlww4phznmv-libopus-1.3.1","/nix/store/njswbyisabvgk02vi4v22yd1lwl80m7r-libsndfile-1.1.0","/nix/store/srqyvqyr1cp5r192xq8vvg2y694w1vyv-webrtc-audio-processing-0.3.1","/nix/store/8ypkjcki98cwblzc4k0kblxz2zpjqj45-libXau-1.0.9","/nix/store/xs3v53gpwwpz34aj5h51rz4wxmjfrf08-libxcb-1.14","/nix/store/w3zzhfl4a7xp0xfflz2gawv02y8ba9z8-libX11-1.8.1","/nix/store/y1ffp4g3yl0ijwdl8lgh4hhq3wl8frcc-dbus-1.14.4-lib","/nix/store/bvihhgw8bh6cqqlj0d4s8cvmm4mqmzfc-pulseaudio-16.1","/nix/store/qvvaq9p7lw05r7szvsx3c17ca5x8h982-libXext-1.3.4","/nix/store/cxhib72pd7n3fzl1yh6lrm4q16l42kws-libglvnd-1.5.0","/nix/store/89zs7rms6x00xfq4dq6m7mjnhkr8a6r4-gnused-4.8","/nix/store/8zxndz5ag0p6s526c2xyllhk1nrn4c3i-audit-tmpdir.sh","/nix/store/bnj8d7mvbkg3vdb07yz74yhl3g107qq5-patch-shebangs.sh","/nix/store/c8n9kcdddp9np665xz6ri61b383nxvz8-move-systemd-user-units.sh","/nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh","/nix/store/dq0xwmsk1g0i2ayg6pb7y87na2knzylh-gcc-wrapper-11.3.0","/nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh","/nix/store/g8xg0i02aqwhgxwd2vnp5ax3d6lrkg1v-strip.sh","/nix/store/hwcdqw4jrjnd37wxqgsd47hd0j8bnj09-gawk-5.1.1","/nix/store/j9p3g8472iijd50vhdprx0nmk2fqn5gv-diffutils-3.8","/nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh","/nix/store/kxw6q8v6isaqjm702d71n2421cxamq68-make-symlinks-relative.sh","/nix/store/m54bmrhj6fqz8nds5zcj97w9s9bckc9v-compress-man-pages.sh","/nix/store/mblgz65m3zv9x548a3d5m96fj2pbwr09-gnumake-4.3","/nix/store/mydc6f4k2z73xlcz7ilif3v2lcaiqvza-findutils-4.9.0","/nix/store/ngg1cv31c8c7bcm2n8ww4g06nq7s4zhm-set-source-date-epoch-to-latest.sh","/nix/store/pr5n59mb4jzmfx6kanwxly0l07p861fg-patchelf-0.15.0","/nix/store/xwl6y60ffijfbhxb754dlxk3pkjgw0d2-ed-1.18","/nix/store/v7ljksji50mg3w61dykaa3n3y79n6nil-patch-2.7.6","/nix/store/wlwcf1nw2b21m4gghj70hbg1v7x53ld8-reproducible-builds.sh","/nix/store/y6aj732zm9m87c82fpvf103a1xb22blp-file-5.43","/nix/store/kmfaajdpyyyg319vfqni5jm9wkxjmf73-stdenv-linux","/nix/store/fzb7khbic8vpcr3m69v6y8qp6jqspdgw-openssl-1.1.1s","/nix/store/9zdxd9grnspixp6iaz7h6564ja550i0q-openssl-1.1.1s-bin","/nix/store/p9zk4lm1902mi3r30kg6fjlmqjay5y8q-openssl-1.1.1s-dev","/nix/store/ii9hqvfq3g2vnsybi1vly9s1j9jcna9k-nodejs-14.21.1","/nix/store/n1wjpwirjdkvkqyfjjg8qafgdhpr5w2m-jest-cli-23.6.0","/nix/store/7sqa8vdyvc3vwh2bq3q7c2kcx1k83iij-libxshmfence-1.3","/nix/store/8gx2zdbvdlhayh3g7006dxipx91rggnh-libelf-0.8.13","/nix/store/h5slhj7gqpqh5q4jb00xdbcwbl8vqqa7-libxml2-2.10.3","/nix/store/8q73rj23w9dms6mq2nwijxsj2lqcmz0r-llvm-14.0.6-lib","/nix/store/cggynsnj7dyk2sxnrr20jvpwcqdiv42f-libpciaccess-0.16","/nix/store/hr321ph174h3whvlvbc0lk5w1n1ljkx7-libdrm-2.4.113","/nix/store/l3y9k2x7cqzcjj9s18z7la9xqsjq6r52-wayland-1.21.0","/nix/store/bk62iwpqiaipgbim564f7zy6prdwpvri-mesa-22.2.3","/nix/store/cr7ldrd6xlq4rgqr99yygy43f77zdk1x-libXfixes-6.0.0","/nix/store/l2p6ikb5wqjcsfnmgcfxmbzi22smr5qa-libXxf86vm-1.1.4","/nix/store/q4hrphx851xvkcnyyvqqyf1yjgmkmiar-mesa-22.2.3-drivers","/nix/store/dj805sw07vvpbxx39c8g67x8qddg0ikw-nodejs-18.12.1","/nix/store/6w8n8fy21yjssg8b1dqkds8diad3v75g-typescript-4.8.4","/nix/store/w8q2bwi6rdhsa1dz9i8mqznddk5l7p26-typescript-language-server-3.3.2","/nix/store/zdcnqq55qi214j46zgw2qa1jp4dpdf2m-yarn-1.22.19","/nix/store/5df7d1vpwcks6l7mnbbqlikvdap97nvp-nix-shell"],"channel":"stable-22_11","channel_nix_path":"/nix/store/2jabpzcs368xsjj6swbhb317z5b6zzyw-nixpkgs-stable-22_11-22.11.tar.gz/nixpkgs-stable-22_11","production":null}}}

.cache/typescript/4.8/node_modules/types-registry/README.md

@@ -0,0 +1,2 @@
+This package contains a listing of all packages published to the @types scope on NPM.
+Generated by [types-publisher](https://github.com/microsoft/DefinitelyTyped-tools/tree/main/packages/publisher#readme).

.cache/typescript/4.8/node_modules/types-registry/package.json

@@ -0,0 +1,52 @@
+{
+  "_from": "types-registry@latest",
+  "_id": "types-registry@0.1.684",
+  "_inBundle": false,
+  "_integrity": "sha512-B6v+g9M+7IJSc1w2THOmTuRKvd/ACxZTGXM18E8MzpHWx1mGUvGGT+RXsSnxNpyqtbjWLeXj8uyyu/MxVOS3xw==",
+  "_location": "/types-registry",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "tag",
+    "registry": true,
+    "raw": "types-registry@latest",
+    "name": "types-registry",
+    "escapedName": "types-registry",
+    "rawSpec": "latest",
+    "saveSpec": null,
+    "fetchSpec": "latest"
+  },
+  "_requiredBy": [
+    "#USER",
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/types-registry/-/types-registry-0.1.684.tgz",
+  "_shasum": "e75966f99e232b8bd09d8fae02fa247ce0f099cd",
+  "_spec": "types-registry@latest",
+  "_where": "/home/runner/Hugging-Face-UI-Exercise-MacBook-Pro-5-3/.cache/typescript/4.8",
+  "author": {
+    "name": "Microsoft Corp."
+  },
+  "bugs": {
+    "url": "https://github.com/microsoft/DefinitelyTyped-tools/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A registry of TypeScript declaration file packages published within the @types scope.",
+  "homepage": "https://github.com/microsoft/DefinitelyTyped-tools#readme",
+  "keywords": [
+    "TypeScript",
+    "declaration",
+    "files",
+    "types",
+    "packages"
+  ],
+  "license": "MIT",
+  "name": "types-registry",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microsoft/DefinitelyTyped-tools.git",
+    "directory": "packages/publisher"
+  },
+  "typesPublisherContentHash": "778261fdb6ff01765ce2e700a234232d9f1fe2a19a84fe4b80c7e61206575cc6",
+  "version": "0.1.684"
+}

.cache/typescript/4.8/package-lock.json

@@ -0,0 +1,11 @@
+{
+  "requires": true,
+  "lockfileVersion": 1,
+  "dependencies": {
+    "types-registry": {
+      "version": "0.1.684",
+      "resolved": "https://registry.npmjs.org/types-registry/-/types-registry-0.1.684.tgz",
+      "integrity": "sha512-B6v+g9M+7IJSc1w2THOmTuRKvd/ACxZTGXM18E8MzpHWx1mGUvGGT+RXsSnxNpyqtbjWLeXj8uyyu/MxVOS3xw=="
+    }
+  }
+}

.cache/typescript/4.8/package.json

@@ -0,0 +1,6 @@
+{
+  "private": true,
+  "dependencies": {
+    "types-registry": "^0.1.684"
+  }
+}

.config/configstore/update-notifier-npm.json

@@ -0,0 +1,4 @@
+{
+	"optOut": false,
+	"lastUpdateCheck": 1708632885794
+}

.deno/deps/https/deno.land/0b6eb9ee05f05f2c53ace8ddc098d2f61379d98eb03a8cb59d785b67cf4d4f6b

@@ -0,0 +1,39 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { SEP } from "./separator.ts";
+
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ *       import { common } from "https://deno.land/std/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ *
+ */
+export function common(paths: string[], sep = SEP): string {
+  const [first = "", ...remaining] = paths;
+  if (first === "" || remaining.length === 0) {
+    return first.substring(0, first.lastIndexOf(sep) + 1);
+  }
+  const parts = first.split(sep);
+
+  let endOfPrefix = parts.length;
+  for (const path of remaining) {
+    const compare = path.split(sep);
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i;
+      }
+    }
+
+    if (endOfPrefix === 0) {
+      return "";
+    }
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep);
+  return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+}

.deno/deps/https/deno.land/0b6eb9ee05f05f2c53ace8ddc098d2f61379d98eb03a8cb59d785b67cf4d4f6b.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "via": "http/2 edgeproxy-h",
+    "date": "Wed, 12 Oct 2022 22:13:12 GMT",
+    "x-amz-version-id": "M.wLwyV70gRKTb540o38M8ccNq0mS67e",
+    "cross-origin-embedder-policy": "same-origin",
+    "cross-origin-resource-policy": "same-origin",
+    "x-cache": "Hit from cloudfront",
+    "content-length": "1166",
+    "x-frame-options": "DENY",
+    "content-type": "application/typescript; charset=utf-8",
+    "cross-origin-opener-policy": "same-origin",
+    "etag": "\"563fa4ed09afad6fac675949f387b257\"",
+    "server-timing": "fetchSource;dur=38",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "vary": "Accept-Encoding, Origin",
+    "access-control-allow-origin": "*",
+    "accept-ranges": "bytes",
+    "age": "29184345",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "x-amz-cf-id": "j2LhhtiGgWvdmIhMvYun-jMqYW7xpW1WrhngSmzdPHVDV17irXG81w==",
+    "x-content-type-options": "nosniff",
+    "cache-control": "public, max-age=31536000, immutable",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-amz-cf-pop": "SEA73-P3",
+    "server": "deno/gcp-us-west1",
+    "last-modified": "Wed, 20 Jan 2021 05:26:04 GMT",
+    "x-amz-replication-status": "FAILED"
+  },
+  "url": "https://deno.land/std@0.84.0/path/common.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 682643628
+  }
+}

.deno/deps/https/deno.land/0ce54a636d537bee3da40798d6ef467c7259312894dd85635945a8d1d0a9ead3

@@ -0,0 +1,15 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+export class DenoStdInternalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DenoStdInternalError";
+  }
+}
+
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new DenoStdInternalError(msg);
+  }
+}

.deno/deps/https/deno.land/0ce54a636d537bee3da40798d6ef467c7259312894dd85635945a8d1d0a9ead3.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "x-amz-cf-pop": "SEA73-P3",
+    "content-length": "405",
+    "accept-ranges": "bytes",
+    "access-control-allow-origin": "*",
+    "x-cache": "Hit from cloudfront",
+    "x-amz-version-id": "G05Z6nJtvYc0K9LFwPhem5xgny19S1Cv",
+    "cache-control": "public, max-age=31536000, immutable",
+    "vary": "Accept-Encoding, Origin",
+    "age": "262792",
+    "cross-origin-embedder-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "server": "deno/gcp-us-west1",
+    "etag": "\"e5ce4111fb107a7ba5b5f7667b7bda6a\"",
+    "cross-origin-opener-policy": "same-origin",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "cross-origin-resource-policy": "same-origin",
+    "x-frame-options": "DENY",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "last-modified": "Fri, 02 Apr 2021 05:03:18 GMT",
+    "server-timing": "fetchSource;dur=8",
+    "via": "http/2 edgeproxy-h",
+    "date": "Tue, 12 Sep 2023 15:59:04 GMT",
+    "x-amz-cf-id": "Xe2xywQ9eahkAqyHANV9C0q2dmf39vGN6ArqjS3o_4rgTicsYUtrbQ==",
+    "content-type": "application/typescript; charset=utf-8",
+    "x-amz-replication-status": "COMPLETED",
+    "x-content-type-options": "nosniff"
+  },
+  "url": "https://deno.land/std@0.92.0/_util/assert.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 970170392
+  }
+}

.deno/deps/https/deno.land/169f4312ba164e3f7d36e8ba945c39a3fefff611217384f877c888d77a3c4377.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "cross-origin-embedder-policy": "same-origin",
+    "date": "Wed, 12 Oct 2022 22:13:12 GMT",
+    "via": "http/2 edgeproxy-h",
+    "age": "29184344",
+    "content-length": "182511",
+    "vary": "Accept-Encoding, Origin",
+    "cross-origin-opener-policy": "same-origin",
+    "x-content-type-options": "nosniff",
+    "server": "deno/gcp-us-west1",
+    "etag": "\"2c7c39d15d727b1a45782009be28a2db\"",
+    "access-control-allow-origin": "*",
+    "accept-ranges": "bytes",
+    "cache-control": "public, max-age=31536000, immutable",
+    "server-timing": "fetchSource;dur=14",
+    "x-amz-cf-id": "RN0Bdfz2yPwV1lnmV2QOs5I_xcLo5Xf0DyOugZKLmcKftolyeZL20g==",
+    "x-frame-options": "DENY",
+    "last-modified": "Thu, 21 Jan 2021 22:00:02 GMT",
+    "x-amz-cf-pop": "SEA73-P3",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-amz-version-id": "eb0JK7sqovn9YW.o3nDt6z1Ui7z7ZSB.",
+    "x-amz-replication-status": "FAILED",
+    "content-type": "application/typescript; charset=utf-8",
+    "cross-origin-resource-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-cache": "Hit from cloudfront"
+  },
+  "url": "https://deno.land/x/media_types@v2.7.1/db.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 960646533
+  }
+}

.deno/deps/https/deno.land/1987df074c07c15283df07b0e8fbe35900df9fdcc9239a24197559f1f383d1dd

@@ -0,0 +1,18 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+export const osType = (() => {
+  if (globalThis.Deno != null) {
+    return Deno.build.os;
+  }
+
+  // deno-lint-ignore no-explicit-any
+  const navigator = (globalThis as any).navigator;
+  if (navigator?.appVersion?.includes?.("Win") ?? false) {
+    return "windows";
+  }
+
+  return "linux";
+})();
+
+export const isWindows = osType === "windows";

.deno/deps/https/deno.land/1987df074c07c15283df07b0e8fbe35900df9fdcc9239a24197559f1f383d1dd.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "via": "http/2 edgeproxy-h",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-cf-pop": "SEA73-P3",
+    "x-amz-replication-status": "FAILED",
+    "content-length": "456",
+    "cross-origin-resource-policy": "same-origin",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-frame-options": "DENY",
+    "x-amz-cf-id": "C4LEERcqWjMSWrp0Q_Q1Lj9bhYboM0DPFapjMrOkksD0EkxCXjzD0A==",
+    "last-modified": "Wed, 20 Jan 2021 05:26:03 GMT",
+    "access-control-allow-origin": "*",
+    "server-timing": "fetchSource;dur=38",
+    "accept-ranges": "bytes",
+    "x-amz-version-id": "n4UwmOs2Dq6YPymtAHM_halsvrbD9_TP",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "etag": "\"73a9f57dcaabd9ea3ecfb4f0582cee60\"",
+    "cross-origin-opener-policy": "same-origin",
+    "date": "Wed, 12 Oct 2022 22:13:12 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "x-cache": "Hit from cloudfront",
+    "cross-origin-embedder-policy": "same-origin",
+    "x-content-type-options": "nosniff",
+    "server": "deno/gcp-us-west1",
+    "age": "29184345",
+    "cache-control": "public, max-age=31536000, immutable",
+    "content-type": "application/typescript; charset=utf-8"
+  },
+  "url": "https://deno.land/std@0.84.0/_util/os.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 682930808
+  }
+}

.deno/deps/https/deno.land/20000027ca53de11171f2184ab15306a7a99339210f33752521b9ab2bcec30bc

@@ -0,0 +1,69 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+import { Deferred, deferred } from "./deferred.ts";
+
+interface TaggedYieldedValue<T> {
+  iterator: AsyncIterableIterator<T>;
+  value: T;
+}
+
+/** The MuxAsyncIterator class multiplexes multiple async iterators into a
+ * single stream. It currently makes an assumption:
+ * - The final result (the value returned and not yielded from the iterator)
+ *   does not matter; if there is any, it is discarded.
+ */
+export class MuxAsyncIterator<T> implements AsyncIterable<T> {
+  private iteratorCount = 0;
+  private yields: Array<TaggedYieldedValue<T>> = [];
+  // deno-lint-ignore no-explicit-any
+  private throws: any[] = [];
+  private signal: Deferred<void> = deferred();
+
+  add(iterator: AsyncIterableIterator<T>): void {
+    ++this.iteratorCount;
+    this.callIteratorNext(iterator);
+  }
+
+  private async callIteratorNext(
+    iterator: AsyncIterableIterator<T>,
+  ): Promise<void> {
+    try {
+      const { value, done } = await iterator.next();
+      if (done) {
+        --this.iteratorCount;
+      } else {
+        this.yields.push({ iterator, value });
+      }
+    } catch (e) {
+      this.throws.push(e);
+    }
+    this.signal.resolve();
+  }
+
+  async *iterate(): AsyncIterableIterator<T> {
+    while (this.iteratorCount > 0) {
+      // Sleep until any of the wrapped iterators yields.
+      await this.signal;
+
+      // Note that while we're looping over `yields`, new items may be added.
+      for (let i = 0; i < this.yields.length; i++) {
+        const { iterator, value } = this.yields[i];
+        yield value;
+        this.callIteratorNext(iterator);
+      }
+
+      if (this.throws.length) {
+        for (const e of this.throws) {
+          throw e;
+        }
+        this.throws.length = 0;
+      }
+      // Clear the `yields` list and reset the `signal` promise.
+      this.yields.length = 0;
+      this.signal = deferred();
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterableIterator<T> {
+    return this.iterate();
+  }
+}

.deno/deps/https/deno.land/20000027ca53de11171f2184ab15306a7a99339210f33752521b9ab2bcec30bc.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "cross-origin-opener-policy": "same-origin",
+    "accept-ranges": "bytes",
+    "age": "28964322",
+    "content-length": "2005",
+    "content-type": "application/typescript; charset=utf-8",
+    "via": "http/2 edgeproxy-h",
+    "x-amz-cf-id": "foMtX0yX5JYdX2F9Dyxuoem6uEAGQZP9dnMpmwuROeg7BylqA-I_4w==",
+    "x-amz-cf-pop": "SEA73-P3",
+    "cross-origin-embedder-policy": "same-origin",
+    "x-amz-version-id": "phII7fkU7ZsJjsthUmX7Q_3V9sfgv43Q",
+    "x-cache": "Hit from cloudfront",
+    "x-content-type-options": "nosniff",
+    "last-modified": "Fri, 02 Apr 2021 05:03:18 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "date": "Sat, 15 Oct 2022 11:20:15 GMT",
+    "x-frame-options": "DENY",
+    "x-amz-replication-status": "FAILED",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "access-control-allow-origin": "*",
+    "cache-control": "public, max-age=31536000, immutable",
+    "cross-origin-resource-policy": "same-origin",
+    "etag": "\"a7665ec4b3e56b1a20c3aabed42f7dd9\"",
+    "server": "deno/gcp-us-west1",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "server-timing": "fetchSource;dur=16"
+  },
+  "url": "https://deno.land/std@0.92.0/async/mux_async_iterator.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 323953111
+  }
+}

.deno/deps/https/deno.land/240abb71b35597950024783a333e95a7489019d12858652d2d75c91020b1a52f

@@ -0,0 +1,48 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+
+// Alphabet chars.
+export const CHAR_UPPERCASE_A = 65; /* A */
+export const CHAR_LOWERCASE_A = 97; /* a */
+export const CHAR_UPPERCASE_Z = 90; /* Z */
+export const CHAR_LOWERCASE_Z = 122; /* z */
+
+// Non-alphabetic chars.
+export const CHAR_DOT = 46; /* . */
+export const CHAR_FORWARD_SLASH = 47; /* / */
+export const CHAR_BACKWARD_SLASH = 92; /* \ */
+export const CHAR_VERTICAL_LINE = 124; /* | */
+export const CHAR_COLON = 58; /* : */
+export const CHAR_QUESTION_MARK = 63; /* ? */
+export const CHAR_UNDERSCORE = 95; /* _ */
+export const CHAR_LINE_FEED = 10; /* \n */
+export const CHAR_CARRIAGE_RETURN = 13; /* \r */
+export const CHAR_TAB = 9; /* \t */
+export const CHAR_FORM_FEED = 12; /* \f */
+export const CHAR_EXCLAMATION_MARK = 33; /* ! */
+export const CHAR_HASH = 35; /* # */
+export const CHAR_SPACE = 32; /*   */
+export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */
+export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */
+export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */
+export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */
+export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */
+export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */
+export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */
+export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */
+export const CHAR_HYPHEN_MINUS = 45; /* - */
+export const CHAR_PLUS = 43; /* + */
+export const CHAR_DOUBLE_QUOTE = 34; /* " */
+export const CHAR_SINGLE_QUOTE = 39; /* ' */
+export const CHAR_PERCENT = 37; /* % */
+export const CHAR_SEMICOLON = 59; /* ; */
+export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */
+export const CHAR_GRAVE_ACCENT = 96; /* ` */
+export const CHAR_AT = 64; /* @ */
+export const CHAR_AMPERSAND = 38; /* & */
+export const CHAR_EQUAL = 61; /* = */
+
+// Digits
+export const CHAR_0 = 48; /* 0 */
+export const CHAR_9 = 57; /* 9 */

.deno/deps/https/deno.land/240abb71b35597950024783a333e95a7489019d12858652d2d75c91020b1a52f.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "last-modified": "Wed, 20 Jan 2021 05:26:04 GMT",
+    "date": "Wed, 12 Oct 2022 22:13:13 GMT",
+    "cache-control": "public, max-age=31536000, immutable",
+    "content-type": "application/typescript; charset=utf-8",
+    "x-amz-replication-status": "FAILED",
+    "cross-origin-resource-policy": "same-origin",
+    "accept-ranges": "bytes",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "vary": "Accept-Encoding, Origin",
+    "server": "deno/gcp-us-west1",
+    "x-amz-cf-id": "XDsaLiu32GlAlW6orfKPyUZP-Q3wNyJjeu5gKnrJp-J-PInlgxz16w==",
+    "x-amz-cf-pop": "SEA73-P3",
+    "age": "29184344",
+    "server-timing": "fetchSource;dur=8",
+    "x-cache": "Hit from cloudfront",
+    "x-amz-version-id": "dGa1UO4xphJcao3sc2rTDHGhl2cnI26d",
+    "etag": "\"750ae0df3aaa0c8fdff773c40588fc59\"",
+    "x-frame-options": "DENY",
+    "access-control-allow-origin": "*",
+    "content-length": "1945",
+    "cross-origin-embedder-policy": "same-origin",
+    "cross-origin-opener-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "via": "http/2 edgeproxy-h",
+    "x-content-type-options": "nosniff"
+  },
+  "url": "https://deno.land/std@0.84.0/path/_constants.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 834319757
+  }
+}

.deno/deps/https/deno.land/2458f931dced104bb23594f63096f7a2afa1e78bba99527b6ad35426d516b247

@@ -0,0 +1,9 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+/* Resolves after the given number of milliseconds. */
+export function delay(ms: number): Promise<void> {
+  return new Promise((res): number =>
+    setTimeout((): void => {
+      res();
+    }, ms)
+  );
+}

.deno/deps/https/deno.land/2458f931dced104bb23594f63096f7a2afa1e78bba99527b6ad35426d516b247.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "x-cache": "Hit from cloudfront",
+    "cross-origin-embedder-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-replication-status": "FAILED",
+    "x-amz-version-id": "heAiVjIsgbCBe51RCfQMlKy_rNZGpWZ9",
+    "x-content-type-options": "nosniff",
+    "cross-origin-opener-policy": "same-origin",
+    "date": "Tue, 25 Oct 2022 13:29:43 GMT",
+    "cross-origin-resource-policy": "same-origin",
+    "access-control-allow-origin": "*",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "server-timing": "fetchSource;dur=18",
+    "vary": "Accept-Encoding, Origin",
+    "accept-ranges": "bytes",
+    "server": "deno/gcp-us-west1",
+    "x-amz-cf-id": "lA96vgtSJPSgBHYf80tJFAf8yW2nfPWZt-hYkH5izcvLBDx6RXMLdA==",
+    "last-modified": "Fri, 02 Apr 2021 05:03:18 GMT",
+    "etag": "\"2a1b90f6d604cf64c28f8f93b98109af\"",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "content-type": "application/typescript; charset=utf-8",
+    "cache-control": "public, max-age=31536000, immutable",
+    "age": "28092554",
+    "via": "http/2 edgeproxy-h",
+    "x-amz-cf-pop": "SEA73-P3",
+    "content-length": "279",
+    "x-frame-options": "DENY"
+  },
+  "url": "https://deno.land/std@0.92.0/async/delay.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 327206309
+  }
+}

.deno/deps/https/deno.land/2d42e05955049935cf121ad3d14d949da14b4c2ec355b1ac41b8bd233b186fc6

@@ -0,0 +1,260 @@
+import { assert } from "../_util/assert.ts";
+
+// MIN_READ is the minimum ArrayBuffer size passed to a read call by
+// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond
+// what is required to hold the contents of r, readFrom() will not grow the
+// underlying buffer.
+const MIN_READ = 32 * 1024;
+const MAX_SIZE = 2 ** 32 - 2;
+
+// `off` is the offset into `dst` where it will at which to begin writing values
+// from `src`.
+// Returns the number of bytes copied.
+function copyBytes(src: Uint8Array, dst: Uint8Array, off = 0) {
+  const r = dst.byteLength - off;
+  if (src.byteLength > r) {
+    src = src.subarray(0, r);
+  }
+  dst.set(src, off);
+  return src.byteLength;
+}
+
+/** A variable-sized buffer of bytes with `read()` and `write()` methods.
+ *
+ * Buffer is almost always used with some I/O like files and sockets. It allows
+ * one to buffer up a download from a socket. Buffer grows and shrinks as
+ * necessary.
+ *
+ * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in
+ * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a
+ * non-standard ArrayBuffer.
+ *
+ * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of
+ * ArrayBuffer.
+ *
+ * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */
+
+export class Buffer {
+  #buf: Uint8Array; // contents are the bytes buf[off : len(buf)]
+  #off = 0; // read at buf[off], write at buf[buf.byteLength]
+
+  constructor(ab?: ArrayBuffer) {
+    if (ab === undefined) {
+      this.#buf = new Uint8Array(0);
+      return;
+    }
+    this.#buf = new Uint8Array(ab);
+  }
+
+  /** Returns a slice holding the unread portion of the buffer.
+   *
+   * The slice is valid for use only until the next buffer modification (that
+   * is, only until the next call to a method like `read()`, `write()`,
+   * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at
+   * least until the next buffer modification, so immediate changes to the
+   * slice will affect the result of future reads.
+   * @param options Defaults to `{ copy: true }`
+   */
+  bytes(options = { copy: true }): Uint8Array {
+    if (options.copy === false) return this.#buf.subarray(this.#off);
+    return this.#buf.slice(this.#off);
+  }
+
+  /** Returns whether the unread portion of the buffer is empty. */
+  empty(): boolean {
+    return this.#buf.byteLength <= this.#off;
+  }
+
+  /** A read only number of bytes of the unread portion of the buffer. */
+  get length(): number {
+    return this.#buf.byteLength - this.#off;
+  }
+
+  /** The read only capacity of the buffer's underlying byte slice, that is,
+   * the total space allocated for the buffer's data. */
+  get capacity(): number {
+    return this.#buf.buffer.byteLength;
+  }
+
+  /** Discards all but the first `n` unread bytes from the buffer but
+   * continues to use the same allocated storage. It throws if `n` is
+   * negative or greater than the length of the buffer. */
+  truncate(n: number): void {
+    if (n === 0) {
+      this.reset();
+      return;
+    }
+    if (n < 0 || n > this.length) {
+      throw Error("bytes.Buffer: truncation out of range");
+    }
+    this.#reslice(this.#off + n);
+  }
+
+  reset(): void {
+    this.#reslice(0);
+    this.#off = 0;
+  }
+
+  #tryGrowByReslice = (n: number) => {
+    const l = this.#buf.byteLength;
+    if (n <= this.capacity - l) {
+      this.#reslice(l + n);
+      return l;
+    }
+    return -1;
+  };
+
+  #reslice = (len: number) => {
+    assert(len <= this.#buf.buffer.byteLength);
+    this.#buf = new Uint8Array(this.#buf.buffer, 0, len);
+  };
+
+  /** Reads the next `p.length` bytes from the buffer or until the buffer is
+   * drained. Returns the number of bytes read. If the buffer has no data to
+   * return, the return is EOF (`null`). */
+  readSync(p: Uint8Array): number | null {
+    if (this.empty()) {
+      // Buffer is empty, reset to recover space.
+      this.reset();
+      if (p.byteLength === 0) {
+        // this edge case is tested in 'bufferReadEmptyAtEOF' test
+        return 0;
+      }
+      return null;
+    }
+    const nread = copyBytes(this.#buf.subarray(this.#off), p);
+    this.#off += nread;
+    return nread;
+  }
+
+  /** Reads the next `p.length` bytes from the buffer or until the buffer is
+   * drained. Resolves to the number of bytes read. If the buffer has no
+   * data to return, resolves to EOF (`null`).
+   *
+   * NOTE: This methods reads bytes synchronously; it's provided for
+   * compatibility with `Reader` interfaces.
+   */
+  read(p: Uint8Array): Promise<number | null> {
+    const rr = this.readSync(p);
+    return Promise.resolve(rr);
+  }
+
+  writeSync(p: Uint8Array): number {
+    const m = this.#grow(p.byteLength);
+    return copyBytes(p, this.#buf, m);
+  }
+
+  /** NOTE: This methods writes bytes synchronously; it's provided for
+   * compatibility with `Writer` interface. */
+  write(p: Uint8Array): Promise<number> {
+    const n = this.writeSync(p);
+    return Promise.resolve(n);
+  }
+
+  #grow = (n: number) => {
+    const m = this.length;
+    // If buffer is empty, reset to recover space.
+    if (m === 0 && this.#off !== 0) {
+      this.reset();
+    }
+    // Fast: Try to grow by means of a reslice.
+    const i = this.#tryGrowByReslice(n);
+    if (i >= 0) {
+      return i;
+    }
+    const c = this.capacity;
+    if (n <= Math.floor(c / 2) - m) {
+      // We can slide things down instead of allocating a new
+      // ArrayBuffer. We only need m+n <= c to slide, but
+      // we instead let capacity get twice as large so we
+      // don't spend all our time copying.
+      copyBytes(this.#buf.subarray(this.#off), this.#buf);
+    } else if (c + n > MAX_SIZE) {
+      throw new Error("The buffer cannot be grown beyond the maximum size.");
+    } else {
+      // Not enough space anywhere, we need to allocate.
+      const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
+      copyBytes(this.#buf.subarray(this.#off), buf);
+      this.#buf = buf;
+    }
+    // Restore this.#off and len(this.#buf).
+    this.#off = 0;
+    this.#reslice(Math.min(m + n, MAX_SIZE));
+    return m;
+  };
+
+  /** Grows the buffer's capacity, if necessary, to guarantee space for
+   * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
+   * the buffer without another allocation. If `n` is negative, `.grow()` will
+   * throw. If the buffer can't grow it will throw an error.
+   *
+   * Based on Go Lang's
+   * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */
+  grow(n: number): void {
+    if (n < 0) {
+      throw Error("Buffer.grow: negative count");
+    }
+    const m = this.#grow(n);
+    this.#reslice(m);
+  }
+
+  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
+   * growing the buffer as needed. It resolves to the number of bytes read.
+   * If the buffer becomes too large, `.readFrom()` will reject with an error.
+   *
+   * Based on Go Lang's
+   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
+  async readFrom(r: Deno.Reader): Promise<number> {
+    let n = 0;
+    const tmp = new Uint8Array(MIN_READ);
+    while (true) {
+      const shouldGrow = this.capacity - this.length < MIN_READ;
+      // read into tmp buffer if there's not enough room
+      // otherwise read directly into the internal buffer
+      const buf = shouldGrow
+        ? tmp
+        : new Uint8Array(this.#buf.buffer, this.length);
+
+      const nread = await r.read(buf);
+      if (nread === null) {
+        return n;
+      }
+
+      // write will grow if needed
+      if (shouldGrow) this.writeSync(buf.subarray(0, nread));
+      else this.#reslice(this.length + nread);
+
+      n += nread;
+    }
+  }
+
+  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
+   * growing the buffer as needed. It returns the number of bytes read. If the
+   * buffer becomes too large, `.readFromSync()` will throw an error.
+   *
+   * Based on Go Lang's
+   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */
+  readFromSync(r: Deno.ReaderSync): number {
+    let n = 0;
+    const tmp = new Uint8Array(MIN_READ);
+    while (true) {
+      const shouldGrow = this.capacity - this.length < MIN_READ;
+      // read into tmp buffer if there's not enough room
+      // otherwise read directly into the internal buffer
+      const buf = shouldGrow
+        ? tmp
+        : new Uint8Array(this.#buf.buffer, this.length);
+
+      const nread = r.readSync(buf);
+      if (nread === null) {
+        return n;
+      }
+
+      // write will grow if needed
+      if (shouldGrow) this.writeSync(buf.subarray(0, nread));
+      else this.#reslice(this.length + nread);
+
+      n += nread;
+    }
+  }
+}

.deno/deps/https/deno.land/2d42e05955049935cf121ad3d14d949da14b4c2ec355b1ac41b8bd233b186fc6.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "content-length": "8611",
+    "x-amz-cf-id": "TM1nvLIJ1ARbK6fhXSMEhLkxW2m67XIIKicuQx9xeZqNvzNNWxizCQ==",
+    "accept-ranges": "bytes",
+    "via": "http/2 edgeproxy-h",
+    "cross-origin-embedder-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-frame-options": "DENY",
+    "age": "28911889",
+    "x-amz-replication-status": "FAILED",
+    "x-content-type-options": "nosniff",
+    "x-amz-version-id": "rhMzDzR7448iIXW6ppubo2MLvN6JQiV4",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "etag": "\"c34569fd68e7ef43167d844b7731b89c\"",
+    "cache-control": "public, max-age=31536000, immutable",
+    "cross-origin-resource-policy": "same-origin",
+    "server-timing": "fetchSource;dur=16",
+    "x-amz-cf-pop": "SEA73-P3",
+    "server": "deno/gcp-us-west1",
+    "x-cache": "Hit from cloudfront",
+    "content-type": "application/typescript; charset=utf-8",
+    "access-control-allow-origin": "*",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "cross-origin-opener-policy": "same-origin",
+    "last-modified": "Fri, 02 Apr 2021 05:03:19 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "date": "Sun, 16 Oct 2022 01:54:08 GMT"
+  },
+  "url": "https://deno.land/std@0.92.0/io/buffer.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 323071632
+  }
+}

.deno/deps/https/deno.land/3b4317ea97e012608910e529127dce91d98e61254b54f99ea91efa07d92b8f44

@@ -0,0 +1,3 @@
+// Copyright 2020 the oak authors. All rights reserved. MIT license.
+
+export { extname } from "https://deno.land/std@0.84.0/path/mod.ts";

.deno/deps/https/deno.land/3b4317ea97e012608910e529127dce91d98e61254b54f99ea91efa07d92b8f44.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "content-length": "138",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-cache": "Hit from cloudfront",
+    "age": "29184344",
+    "server-timing": "fetchSource;dur=8",
+    "content-type": "application/typescript; charset=utf-8",
+    "server": "deno/gcp-us-west1",
+    "via": "http/2 edgeproxy-h",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "date": "Wed, 12 Oct 2022 22:13:12 GMT",
+    "x-amz-cf-pop": "SEA73-P3",
+    "accept-ranges": "bytes",
+    "cross-origin-embedder-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-replication-status": "FAILED",
+    "last-modified": "Thu, 21 Jan 2021 22:00:01 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "cross-origin-resource-policy": "same-origin",
+    "x-amz-version-id": "wIJvRMivbXZPHNDnPCOAWDvOX151ZbqX",
+    "x-content-type-options": "nosniff",
+    "cross-origin-opener-policy": "same-origin",
+    "access-control-allow-origin": "*",
+    "cache-control": "public, max-age=31536000, immutable",
+    "x-frame-options": "DENY",
+    "x-amz-cf-id": "WXgjgPjAM-9Zuo32nU7DHyh8023hlTtW4Z7QcSefkLbevaM736YJVQ==",
+    "etag": "\"4587fa3fc70c9510c07ceba5e5c25346\""
+  },
+  "url": "https://deno.land/x/media_types@v2.7.1/deps.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 840987197
+  }
+}

.deno/deps/https/deno.land/4e07f5fc21ab1b67b23874d4aec7875cfe6150e248d2e7676c7fad62ad05152b

@@ -0,0 +1,1002 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+
+import type { FormatInputPathObject, ParsedPath } from "./_interface.ts";
+import {
+  CHAR_BACKWARD_SLASH,
+  CHAR_COLON,
+  CHAR_DOT,
+  CHAR_QUESTION_MARK,
+} from "./_constants.ts";
+
+import {
+  _format,
+  assertPath,
+  encodeWhitespace,
+  isPathSeparator,
+  isWindowsDeviceRoot,
+  normalizeString,
+} from "./_util.ts";
+import { assert } from "../_util/assert.ts";
+
+export const sep = "\\";
+export const delimiter = ";";
+
+/**
+ * Resolves path segments into a `path`
+ * @param pathSegments to process to path
+ */
+export function resolve(...pathSegments: string[]): string {
+  let resolvedDevice = "";
+  let resolvedTail = "";
+  let resolvedAbsolute = false;
+
+  for (let i = pathSegments.length - 1; i >= -1; i--) {
+    let path: string;
+    if (i >= 0) {
+      path = pathSegments[i];
+    } else if (!resolvedDevice) {
+      if (globalThis.Deno == null) {
+        throw new TypeError("Resolved a drive-letter-less path without a CWD.");
+      }
+      path = Deno.cwd();
+    } else {
+      if (globalThis.Deno == null) {
+        throw new TypeError("Resolved a relative path without a CWD.");
+      }
+      // Windows has the concept of drive-specific current working
+      // directories. If we've resolved a drive letter but not yet an
+      // absolute path, get cwd for that drive, or the process cwd if
+      // the drive cwd is not available. We're sure the device is not
+      // a UNC path at this points, because UNC paths are always absolute.
+      path = Deno.env.get(`=${resolvedDevice}`) || Deno.cwd();
+
+      // Verify that a cwd was found and that it actually points
+      // to our drive. If not, default to the drive's root.
+      if (
+        path === undefined ||
+        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`
+      ) {
+        path = `${resolvedDevice}\\`;
+      }
+    }
+
+    assertPath(path);
+
+    const len = path.length;
+
+    // Skip empty entries
+    if (len === 0) continue;
+
+    let rootEnd = 0;
+    let device = "";
+    let isAbsolute = false;
+    const code = path.charCodeAt(0);
+
+    // Try to match a root
+    if (len > 1) {
+      if (isPathSeparator(code)) {
+        // Possible UNC root
+
+        // If we started with a separator, we know we at least have an
+        // absolute path of some kind (UNC or otherwise)
+        isAbsolute = true;
+
+        if (isPathSeparator(path.charCodeAt(1))) {
+          // Matched double path separator at beginning
+          let j = 2;
+          let last = j;
+          // Match 1 or more non-path separators
+          for (; j < len; ++j) {
+            if (isPathSeparator(path.charCodeAt(j))) break;
+          }
+          if (j < len && j !== last) {
+            const firstPart = path.slice(last, j);
+            // Matched!
+            last = j;
+            // Match 1 or more path separators
+            for (; j < len; ++j) {
+              if (!isPathSeparator(path.charCodeAt(j))) break;
+            }
+            if (j < len && j !== last) {
+              // Matched!
+              last = j;
+              // Match 1 or more non-path separators
+              for (; j < len; ++j) {
+                if (isPathSeparator(path.charCodeAt(j))) break;
+              }
+              if (j === len) {
+                // We matched a UNC root only
+                device = `\\\\${firstPart}\\${path.slice(last)}`;
+                rootEnd = j;
+              } else if (j !== last) {
+                // We matched a UNC root with leftovers
+
+                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                rootEnd = j;
+              }
+            }
+          }
+        } else {
+          rootEnd = 1;
+        }
+      } else if (isWindowsDeviceRoot(code)) {
+        // Possible device root
+
+        if (path.charCodeAt(1) === CHAR_COLON) {
+          device = path.slice(0, 2);
+          rootEnd = 2;
+          if (len > 2) {
+            if (isPathSeparator(path.charCodeAt(2))) {
+              // Treat separator following drive name as an absolute path
+              // indicator
+              isAbsolute = true;
+              rootEnd = 3;
+            }
+          }
+        }
+      }
+    } else if (isPathSeparator(code)) {
+      // `path` contains just a path separator
+      rootEnd = 1;
+      isAbsolute = true;
+    }
+
+    if (
+      device.length > 0 &&
+      resolvedDevice.length > 0 &&
+      device.toLowerCase() !== resolvedDevice.toLowerCase()
+    ) {
+      // This path points to another device so it is not applicable
+      continue;
+    }
+
+    if (resolvedDevice.length === 0 && device.length > 0) {
+      resolvedDevice = device;
+    }
+    if (!resolvedAbsolute) {
+      resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+      resolvedAbsolute = isAbsolute;
+    }
+
+    if (resolvedAbsolute && resolvedDevice.length > 0) break;
+  }
+
+  // At this point the path should be resolved to a full absolute path,
+  // but handle relative paths to be safe (might happen when process.cwd()
+  // fails)
+
+  // Normalize the tail path
+  resolvedTail = normalizeString(
+    resolvedTail,
+    !resolvedAbsolute,
+    "\\",
+    isPathSeparator,
+  );
+
+  return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
+}
+
+/**
+ * Normalizes a `path`
+ * @param path to normalize
+ */
+export function normalize(path: string): string {
+  assertPath(path);
+  const len = path.length;
+  if (len === 0) return ".";
+  let rootEnd = 0;
+  let device: string | undefined;
+  let isAbsolute = false;
+  const code = path.charCodeAt(0);
+
+  // Try to match a root
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      // If we started with a separator, we know we at least have an absolute
+      // path of some kind (UNC or otherwise)
+      isAbsolute = true;
+
+      if (isPathSeparator(path.charCodeAt(1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        for (; j < len; ++j) {
+          if (isPathSeparator(path.charCodeAt(j))) break;
+        }
+        if (j < len && j !== last) {
+          const firstPart = path.slice(last, j);
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path.charCodeAt(j))) break;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            for (; j < len; ++j) {
+              if (isPathSeparator(path.charCodeAt(j))) break;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+              // Return the normalized version of the UNC root since there
+              // is nothing left to process
+
+              return `\\\\${firstPart}\\${path.slice(last)}\\`;
+            } else if (j !== last) {
+              // We matched a UNC root with leftovers
+
+              device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+              rootEnd = j;
+            }
+          }
+        }
+      } else {
+        rootEnd = 1;
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      // Possible device root
+
+      if (path.charCodeAt(1) === CHAR_COLON) {
+        device = path.slice(0, 2);
+        rootEnd = 2;
+        if (len > 2) {
+          if (isPathSeparator(path.charCodeAt(2))) {
+            // Treat separator following drive name as an absolute path
+            // indicator
+            isAbsolute = true;
+            rootEnd = 3;
+          }
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    // `path` contains just a path separator, exit early to avoid unnecessary
+    // work
+    return "\\";
+  }
+
+  let tail: string;
+  if (rootEnd < len) {
+    tail = normalizeString(
+      path.slice(rootEnd),
+      !isAbsolute,
+      "\\",
+      isPathSeparator,
+    );
+  } else {
+    tail = "";
+  }
+  if (tail.length === 0 && !isAbsolute) tail = ".";
+  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {
+    tail += "\\";
+  }
+  if (device === undefined) {
+    if (isAbsolute) {
+      if (tail.length > 0) return `\\${tail}`;
+      else return "\\";
+    } else if (tail.length > 0) {
+      return tail;
+    } else {
+      return "";
+    }
+  } else if (isAbsolute) {
+    if (tail.length > 0) return `${device}\\${tail}`;
+    else return `${device}\\`;
+  } else if (tail.length > 0) {
+    return device + tail;
+  } else {
+    return device;
+  }
+}
+
+/**
+ * Verifies whether path is absolute
+ * @param path to verify
+ */
+export function isAbsolute(path: string): boolean {
+  assertPath(path);
+  const len = path.length;
+  if (len === 0) return false;
+
+  const code = path.charCodeAt(0);
+  if (isPathSeparator(code)) {
+    return true;
+  } else if (isWindowsDeviceRoot(code)) {
+    // Possible device root
+
+    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {
+      if (isPathSeparator(path.charCodeAt(2))) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export function join(...paths: string[]): string {
+  const pathsCount = paths.length;
+  if (pathsCount === 0) return ".";
+
+  let joined: string | undefined;
+  let firstPart: string | null = null;
+  for (let i = 0; i < pathsCount; ++i) {
+    const path = paths[i];
+    assertPath(path);
+    if (path.length > 0) {
+      if (joined === undefined) joined = firstPart = path;
+      else joined += `\\${path}`;
+    }
+  }
+
+  if (joined === undefined) return ".";
+
+  // Make sure that the joined path doesn't start with two slashes, because
+  // normalize() will mistake it for an UNC path then.
+  //
+  // This step is skipped when it is very clear that the user actually
+  // intended to point at an UNC path. This is assumed when the first
+  // non-empty string arguments starts with exactly two slashes followed by
+  // at least one more non-slash character.
+  //
+  // Note that for normalize() to treat a path as an UNC path it needs to
+  // have at least 2 components, so we don't filter for that here.
+  // This means that the user can use join to construct UNC paths from
+  // a server name and a share name; for example:
+  //   path.join('//server', 'share') -> '\\\\server\\share\\')
+  let needsReplace = true;
+  let slashCount = 0;
+  assert(firstPart != null);
+  if (isPathSeparator(firstPart.charCodeAt(0))) {
+    ++slashCount;
+    const firstLen = firstPart.length;
+    if (firstLen > 1) {
+      if (isPathSeparator(firstPart.charCodeAt(1))) {
+        ++slashCount;
+        if (firstLen > 2) {
+          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;
+          else {
+            // We matched a UNC path in the first part
+            needsReplace = false;
+          }
+        }
+      }
+    }
+  }
+  if (needsReplace) {
+    // Find any more consecutive slashes we need to replace
+    for (; slashCount < joined.length; ++slashCount) {
+      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;
+    }
+
+    // Replace the slashes if needed
+    if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
+  }
+
+  return normalize(joined);
+}
+
+/**
+ * It will solve the relative path from `from` to `to`, for instance:
+ *  from = 'C:\\orandea\\test\\aaa'
+ *  to = 'C:\\orandea\\impl\\bbb'
+ * The output of the function should be: '..\\..\\impl\\bbb'
+ * @param from relative path
+ * @param to relative path
+ */
+export function relative(from: string, to: string): string {
+  assertPath(from);
+  assertPath(to);
+
+  if (from === to) return "";
+
+  const fromOrig = resolve(from);
+  const toOrig = resolve(to);
+
+  if (fromOrig === toOrig) return "";
+
+  from = fromOrig.toLowerCase();
+  to = toOrig.toLowerCase();
+
+  if (from === to) return "";
+
+  // Trim any leading backslashes
+  let fromStart = 0;
+  let fromEnd = from.length;
+  for (; fromStart < fromEnd; ++fromStart) {
+    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;
+  }
+  // Trim trailing backslashes (applicable to UNC paths only)
+  for (; fromEnd - 1 > fromStart; --fromEnd) {
+    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;
+  }
+  const fromLen = fromEnd - fromStart;
+
+  // Trim any leading backslashes
+  let toStart = 0;
+  let toEnd = to.length;
+  for (; toStart < toEnd; ++toStart) {
+    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;
+  }
+  // Trim trailing backslashes (applicable to UNC paths only)
+  for (; toEnd - 1 > toStart; --toEnd) {
+    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;
+  }
+  const toLen = toEnd - toStart;
+
+  // Compare paths to find the longest common path from root
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+          // We get here if `from` is the exact base path for `to`.
+          // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
+          return toOrig.slice(toStart + i + 1);
+        } else if (i === 2) {
+          // We get here if `from` is the device root.
+          // For example: from='C:\\'; to='C:\\foo'
+          return toOrig.slice(toStart + i);
+        }
+      }
+      if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
+          // We get here if `to` is the exact base path for `from`.
+          // For example: from='C:\\foo\\bar'; to='C:\\foo'
+          lastCommonSep = i;
+        } else if (i === 2) {
+          // We get here if `to` is the device root.
+          // For example: from='C:\\foo\\bar'; to='C:\\'
+          lastCommonSep = 3;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode) break;
+    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;
+  }
+
+  // We found a mismatch before the first common path separator was seen, so
+  // return the original `to`.
+  if (i !== length && lastCommonSep === -1) {
+    return toOrig;
+  }
+
+  let out = "";
+  if (lastCommonSep === -1) lastCommonSep = 0;
+  // Generate the relative path based on the path difference between `to` and
+  // `from`
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+      if (out.length === 0) out += "..";
+      else out += "\\..";
+    }
+  }
+
+  // Lastly, append the rest of the destination (`to`) path that comes after
+  // the common path parts
+  if (out.length > 0) {
+    return out + toOrig.slice(toStart + lastCommonSep, toEnd);
+  } else {
+    toStart += lastCommonSep;
+    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;
+    return toOrig.slice(toStart, toEnd);
+  }
+}
+
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export function toNamespacedPath(path: string): string {
+  // Note: this will *probably* throw somewhere.
+  if (typeof path !== "string") return path;
+  if (path.length === 0) return "";
+
+  const resolvedPath = resolve(path);
+
+  if (resolvedPath.length >= 3) {
+    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+      // Possible UNC root
+
+      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+        const code = resolvedPath.charCodeAt(2);
+        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+          // Matched non-long UNC root, convert the path to a long UNC path
+          return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+        }
+      }
+    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+      // Possible device root
+
+      if (
+        resolvedPath.charCodeAt(1) === CHAR_COLON &&
+        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH
+      ) {
+        // Matched device root, convert the path to a long UNC path
+        return `\\\\?\\${resolvedPath}`;
+      }
+    }
+  }
+
+  return path;
+}
+
+/**
+ * Return the directory name of a `path`.
+ * @param path to determine name for
+ */
+export function dirname(path: string): string {
+  assertPath(path);
+  const len = path.length;
+  if (len === 0) return ".";
+  let rootEnd = -1;
+  let end = -1;
+  let matchedSlash = true;
+  let offset = 0;
+  const code = path.charCodeAt(0);
+
+  // Try to match a root
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      rootEnd = offset = 1;
+
+      if (isPathSeparator(path.charCodeAt(1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        for (; j < len; ++j) {
+          if (isPathSeparator(path.charCodeAt(j))) break;
+        }
+        if (j < len && j !== last) {
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path.charCodeAt(j))) break;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            for (; j < len; ++j) {
+              if (isPathSeparator(path.charCodeAt(j))) break;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+              return path;
+            }
+            if (j !== last) {
+              // We matched a UNC root with leftovers
+
+              // Offset by 1 to include the separator after the UNC root to
+              // treat it as a "normal root" on top of a (UNC) root
+              rootEnd = offset = j + 1;
+            }
+          }
+        }
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      // Possible device root
+
+      if (path.charCodeAt(1) === CHAR_COLON) {
+        rootEnd = offset = 2;
+        if (len > 2) {
+          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    // `path` contains just a path separator, exit early to avoid
+    // unnecessary work
+    return path;
+  }
+
+  for (let i = len - 1; i >= offset; --i) {
+    if (isPathSeparator(path.charCodeAt(i))) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      // We saw the first non-path separator
+      matchedSlash = false;
+    }
+  }
+
+  if (end === -1) {
+    if (rootEnd === -1) return ".";
+    else end = rootEnd;
+  }
+  return path.slice(0, end);
+}
+
+/**
+ * Return the last portion of a `path`. Trailing directory separators are ignored.
+ * @param path to process
+ * @param ext of path directory
+ */
+export function basename(path: string, ext = ""): string {
+  if (ext !== undefined && typeof ext !== "string") {
+    throw new TypeError('"ext" argument must be a string');
+  }
+
+  assertPath(path);
+
+  let start = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let i: number;
+
+  // Check for a drive letter prefix so as not to mistake the following
+  // path separator as an extra separator at the end of the path that can be
+  // disregarded
+  if (path.length >= 2) {
+    const drive = path.charCodeAt(0);
+    if (isWindowsDeviceRoot(drive)) {
+      if (path.charCodeAt(1) === CHAR_COLON) start = 2;
+    }
+  }
+
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path) return "";
+    let extIdx = ext.length - 1;
+    let firstNonSlashEnd = -1;
+    for (i = path.length - 1; i >= start; --i) {
+      const code = path.charCodeAt(i);
+      if (isPathSeparator(code)) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1) {
+          // We saw the first non-path separator, remember this index in case
+          // we need it if the extension ends up not matching
+          matchedSlash = false;
+          firstNonSlashEnd = i + 1;
+        }
+        if (extIdx >= 0) {
+          // Try to match the explicit extension
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1) {
+              // We matched the extension, so mark this as the end of our path
+              // component
+              end = i;
+            }
+          } else {
+            // Extension does not match, so our result is the entire path
+            // component
+            extIdx = -1;
+            end = firstNonSlashEnd;
+          }
+        }
+      }
+    }
+
+    if (start === end) end = firstNonSlashEnd;
+    else if (end === -1) end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1; i >= start; --i) {
+      if (isPathSeparator(path.charCodeAt(i))) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // path component
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+
+    if (end === -1) return "";
+    return path.slice(start, end);
+  }
+}
+
+/**
+ * Return the extension of the `path`.
+ * @param path with extension
+ */
+export function extname(path: string): string {
+  assertPath(path);
+  let start = 0;
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find
+  let preDotState = 0;
+
+  // Check for a drive letter prefix so as not to mistake the following
+  // path separator as an extra separator at the end of the path that can be
+  // disregarded
+
+  if (
+    path.length >= 2 &&
+    path.charCodeAt(1) === CHAR_COLON &&
+    isWindowsDeviceRoot(path.charCodeAt(0))
+  ) {
+    start = startPart = 2;
+  }
+
+  for (let i = path.length - 1; i >= start; --i) {
+    const code = path.charCodeAt(i);
+    if (isPathSeparator(code)) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      // If this is our first dot, mark it as the start of our extension
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    return "";
+  }
+  return path.slice(startDot, end);
+}
+
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export function format(pathObject: FormatInputPathObject): string {
+  if (pathObject === null || typeof pathObject !== "object") {
+    throw new TypeError(
+      `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`,
+    );
+  }
+  return _format("\\", pathObject);
+}
+
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export function parse(path: string): ParsedPath {
+  assertPath(path);
+
+  const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" };
+
+  const len = path.length;
+  if (len === 0) return ret;
+
+  let rootEnd = 0;
+  let code = path.charCodeAt(0);
+
+  // Try to match a root
+  if (len > 1) {
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      rootEnd = 1;
+      if (isPathSeparator(path.charCodeAt(1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        for (; j < len; ++j) {
+          if (isPathSeparator(path.charCodeAt(j))) break;
+        }
+        if (j < len && j !== last) {
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          for (; j < len; ++j) {
+            if (!isPathSeparator(path.charCodeAt(j))) break;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            for (; j < len; ++j) {
+              if (isPathSeparator(path.charCodeAt(j))) break;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+
+              rootEnd = j;
+            } else if (j !== last) {
+              // We matched a UNC root with leftovers
+
+              rootEnd = j + 1;
+            }
+          }
+        }
+      }
+    } else if (isWindowsDeviceRoot(code)) {
+      // Possible device root
+
+      if (path.charCodeAt(1) === CHAR_COLON) {
+        rootEnd = 2;
+        if (len > 2) {
+          if (isPathSeparator(path.charCodeAt(2))) {
+            if (len === 3) {
+              // `path` contains just a drive root, exit early to avoid
+              // unnecessary work
+              ret.root = ret.dir = path;
+              return ret;
+            }
+            rootEnd = 3;
+          }
+        } else {
+          // `path` contains just a drive root, exit early to avoid
+          // unnecessary work
+          ret.root = ret.dir = path;
+          return ret;
+        }
+      }
+    }
+  } else if (isPathSeparator(code)) {
+    // `path` contains just a path separator, exit early to avoid
+    // unnecessary work
+    ret.root = ret.dir = path;
+    return ret;
+  }
+
+  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);
+
+  let startDot = -1;
+  let startPart = rootEnd;
+  let end = -1;
+  let matchedSlash = true;
+  let i = path.length - 1;
+
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find
+  let preDotState = 0;
+
+  // Get non-dir info
+  for (; i >= rootEnd; --i) {
+    code = path.charCodeAt(i);
+    if (isPathSeparator(code)) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      // If this is our first dot, mark it as the start of our extension
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    if (end !== -1) {
+      ret.base = ret.name = path.slice(startPart, end);
+    }
+  } else {
+    ret.name = path.slice(startPart, startDot);
+    ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+
+  // If the directory is the root, use the entire root as the `dir` including
+  // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
+  // trailing slash (`C:\abc\def` -> `C:\abc`).
+  if (startPart > 0 && startPart !== rootEnd) {
+    ret.dir = path.slice(0, startPart - 1);
+  } else ret.dir = ret.root;
+
+  return ret;
+}
+
+/**
+ * Converts a file URL to a path string.
+ *
+ *      fromFileUrl("file:///home/foo"); // "\\home\\foo"
+ *      fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo"
+ *      fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo"
+ * @param url of a file URL
+ */
+export function fromFileUrl(url: string | URL): string {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol != "file:") {
+    throw new TypeError("Must be a file URL.");
+  }
+  let path = decodeURIComponent(
+    url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
+  ).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\");
+  if (url.hostname != "") {
+    // Note: The `URL` implementation guarantees that the drive letter and
+    // hostname are mutually exclusive. Otherwise it would not have been valid
+    // to append the hostname and path like this.
+    path = `\\\\${url.hostname}${path}`;
+  }
+  return path;
+}
+
+/**
+ * Converts a path string to a file URL.
+ *
+ *      toFileUrl("\\home\\foo"); // new URL("file:///home/foo")
+ *      toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo")
+ *      toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo")
+ * @param path to convert to file URL
+ */
+export function toFileUrl(path: string): URL {
+  if (!isAbsolute(path)) {
+    throw new TypeError("Must be an absolute path.");
+  }
+  const [, hostname, pathname] = path.match(
+    /^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/,
+  )!;
+  const url = new URL("file:///");
+  url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+  if (hostname != null && hostname != "localhost") {
+    url.hostname = hostname;
+    if (!url.hostname) {
+      throw new TypeError("Invalid hostname.");
+    }
+  }
+  return url;
+}

.deno/deps/https/deno.land/4e07f5fc21ab1b67b23874d4aec7875cfe6150e248d2e7676c7fad62ad05152b.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "access-control-allow-origin": "*",
+    "content-type": "application/typescript; charset=utf-8",
+    "cross-origin-resource-policy": "same-origin",
+    "age": "28100052",
+    "date": "Tue, 25 Oct 2022 11:24:44 GMT",
+    "server-timing": "fetchSource;dur=10",
+    "cross-origin-embedder-policy": "same-origin",
+    "accept-ranges": "bytes",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "cross-origin-opener-policy": "same-origin",
+    "vary": "Accept-Encoding, Origin",
+    "x-amz-cf-id": "ySfnQL_9gGoKFrX7xQr8iErK8jF0_OWOabSiMdfrU_jRFS5BQ4o3LQ==",
+    "etag": "\"8cd6375845bd2e2a3e4f627d07498817\"",
+    "x-amz-replication-status": "FAILED",
+    "server": "deno/gcp-us-west1",
+    "content-length": "29833",
+    "via": "http/2 edgeproxy-h",
+    "x-content-type-options": "nosniff",
+    "x-cache": "Hit from cloudfront",
+    "x-amz-version-id": "agrN.hZVQQKbgItsLNJrIYyJITX11fCa",
+    "x-frame-options": "DENY",
+    "last-modified": "Fri, 02 Apr 2021 05:03:20 GMT",
+    "cache-control": "public, max-age=31536000, immutable",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-cf-pop": "SEA73-P3"
+  },
+  "url": "https://deno.land/std@0.92.0/path/win32.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 897440827
+  }
+}

.deno/deps/https/deno.land/59e46148ccca57c14d2755561933862de4647177b1493b50d6963147427f5e11

@@ -0,0 +1,504 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+
+import type { FormatInputPathObject, ParsedPath } from "./_interface.ts";
+import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./_constants.ts";
+
+import {
+  _format,
+  assertPath,
+  isPosixPathSeparator,
+  normalizeString,
+} from "./_util.ts";
+
+export const sep = "/";
+export const delimiter = ":";
+
+// path.resolve([from ...], to)
+/**
+ * Resolves `pathSegments` into an absolute path.
+ * @param pathSegments an array of path segments
+ */
+export function resolve(...pathSegments: string[]): string {
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+
+  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path: string;
+
+    if (i >= 0) path = pathSegments[i];
+    else {
+      if (globalThis.Deno == null) {
+        throw new TypeError("Resolved a relative path without a CWD.");
+      }
+      path = Deno.cwd();
+    }
+
+    assertPath(path);
+
+    // Skip empty entries
+    if (path.length === 0) {
+      continue;
+    }
+
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  }
+
+  // At this point the path should be resolved to a full absolute path, but
+  // handle relative paths to be safe (might happen when process.cwd() fails)
+
+  // Normalize the path
+  resolvedPath = normalizeString(
+    resolvedPath,
+    !resolvedAbsolute,
+    "/",
+    isPosixPathSeparator,
+  );
+
+  if (resolvedAbsolute) {
+    if (resolvedPath.length > 0) return `/${resolvedPath}`;
+    else return "/";
+  } else if (resolvedPath.length > 0) return resolvedPath;
+  else return ".";
+}
+
+/**
+ * Normalize the `path`, resolving `'..'` and `'.'` segments.
+ * @param path to be normalized
+ */
+export function normalize(path: string): string {
+  assertPath(path);
+
+  if (path.length === 0) return ".";
+
+  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  const trailingSeparator =
+    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
+
+  // Normalize the path
+  path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
+
+  if (path.length === 0 && !isAbsolute) path = ".";
+  if (path.length > 0 && trailingSeparator) path += "/";
+
+  if (isAbsolute) return `/${path}`;
+  return path;
+}
+
+/**
+ * Verifies whether provided path is absolute
+ * @param path to be verified as absolute
+ */
+export function isAbsolute(path: string): boolean {
+  assertPath(path);
+  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+}
+
+/**
+ * Join all given a sequence of `paths`,then normalizes the resulting path.
+ * @param paths to be joined and normalized
+ */
+export function join(...paths: string[]): string {
+  if (paths.length === 0) return ".";
+  let joined: string | undefined;
+  for (let i = 0, len = paths.length; i < len; ++i) {
+    const path = paths[i];
+    assertPath(path);
+    if (path.length > 0) {
+      if (!joined) joined = path;
+      else joined += `/${path}`;
+    }
+  }
+  if (!joined) return ".";
+  return normalize(joined);
+}
+
+/**
+ * Return the relative path from `from` to `to` based on current working directory.
+ * @param from path in current working directory
+ * @param to path in current working directory
+ */
+export function relative(from: string, to: string): string {
+  assertPath(from);
+  assertPath(to);
+
+  if (from === to) return "";
+
+  from = resolve(from);
+  to = resolve(to);
+
+  if (from === to) return "";
+
+  // Trim any leading backslashes
+  let fromStart = 1;
+  const fromEnd = from.length;
+  for (; fromStart < fromEnd; ++fromStart) {
+    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;
+  }
+  const fromLen = fromEnd - fromStart;
+
+  // Trim any leading backslashes
+  let toStart = 1;
+  const toEnd = to.length;
+  for (; toStart < toEnd; ++toStart) {
+    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;
+  }
+  const toLen = toEnd - toStart;
+
+  // Compare paths to find the longest common path from root
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
+          // We get here if `from` is the exact base path for `to`.
+          // For example: from='/foo/bar'; to='/foo/bar/baz'
+          return to.slice(toStart + i + 1);
+        } else if (i === 0) {
+          // We get here if `from` is the root
+          // For example: from='/'; to='/foo'
+          return to.slice(toStart + i);
+        }
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
+          // We get here if `to` is the exact base path for `from`.
+          // For example: from='/foo/bar/baz'; to='/foo/bar'
+          lastCommonSep = i;
+        } else if (i === 0) {
+          // We get here if `to` is the root.
+          // For example: from='/foo'; to='/'
+          lastCommonSep = 0;
+        }
+      }
+      break;
+    }
+    const fromCode = from.charCodeAt(fromStart + i);
+    const toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode) break;
+    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
+  }
+
+  let out = "";
+  // Generate the relative path based on the path difference between `to`
+  // and `from`
+  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (out.length === 0) out += "..";
+      else out += "/..";
+    }
+  }
+
+  // Lastly, append the rest of the destination (`to`) path that comes after
+  // the common path parts
+  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);
+  else {
+    toStart += lastCommonSep;
+    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;
+    return to.slice(toStart);
+  }
+}
+
+/**
+ * Resolves path to a namespace path
+ * @param path to resolve to namespace
+ */
+export function toNamespacedPath(path: string): string {
+  // Non-op on posix systems
+  return path;
+}
+
+/**
+ * Return the directory name of a `path`.
+ * @param path to determine name for
+ */
+export function dirname(path: string): string {
+  assertPath(path);
+  if (path.length === 0) return ".";
+  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let end = -1;
+  let matchedSlash = true;
+  for (let i = path.length - 1; i >= 1; --i) {
+    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      // We saw the first non-path separator
+      matchedSlash = false;
+    }
+  }
+
+  if (end === -1) return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1) return "//";
+  return path.slice(0, end);
+}
+
+/**
+ * Return the last portion of a `path`. Trailing directory separators are ignored.
+ * @param path to process
+ * @param ext of path directory
+ */
+export function basename(path: string, ext = ""): string {
+  if (ext !== undefined && typeof ext !== "string") {
+    throw new TypeError('"ext" argument must be a string');
+  }
+  assertPath(path);
+
+  let start = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let i: number;
+
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path) return "";
+    let extIdx = ext.length - 1;
+    let firstNonSlashEnd = -1;
+    for (i = path.length - 1; i >= 0; --i) {
+      const code = path.charCodeAt(i);
+      if (code === CHAR_FORWARD_SLASH) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1) {
+          // We saw the first non-path separator, remember this index in case
+          // we need it if the extension ends up not matching
+          matchedSlash = false;
+          firstNonSlashEnd = i + 1;
+        }
+        if (extIdx >= 0) {
+          // Try to match the explicit extension
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1) {
+              // We matched the extension, so mark this as the end of our path
+              // component
+              end = i;
+            }
+          } else {
+            // Extension does not match, so our result is the entire path
+            // component
+            extIdx = -1;
+            end = firstNonSlashEnd;
+          }
+        }
+      }
+    }
+
+    if (start === end) end = firstNonSlashEnd;
+    else if (end === -1) end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1; i >= 0; --i) {
+      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // path component
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+
+    if (end === -1) return "";
+    return path.slice(start, end);
+  }
+}
+
+/**
+ * Return the extension of the `path`.
+ * @param path with extension
+ */
+export function extname(path: string): string {
+  assertPath(path);
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find
+  let preDotState = 0;
+  for (let i = path.length - 1; i >= 0; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      // If this is our first dot, mark it as the start of our extension
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    return "";
+  }
+  return path.slice(startDot, end);
+}
+
+/**
+ * Generate a path from `FormatInputPathObject` object.
+ * @param pathObject with path
+ */
+export function format(pathObject: FormatInputPathObject): string {
+  if (pathObject === null || typeof pathObject !== "object") {
+    throw new TypeError(
+      `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`,
+    );
+  }
+  return _format("/", pathObject);
+}
+
+/**
+ * Return a `ParsedPath` object of the `path`.
+ * @param path to process
+ */
+export function parse(path: string): ParsedPath {
+  assertPath(path);
+
+  const ret: ParsedPath = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0) return ret;
+  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
+  let start: number;
+  if (isAbsolute) {
+    ret.root = "/";
+    start = 1;
+  } else {
+    start = 0;
+  }
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  let i = path.length - 1;
+
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find
+  let preDotState = 0;
+
+  // Get non-dir info
+  for (; i >= start; --i) {
+    const code = path.charCodeAt(i);
+    if (code === CHAR_FORWARD_SLASH) {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (code === CHAR_DOT) {
+      // If this is our first dot, mark it as the start of our extension
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    if (end !== -1) {
+      if (startPart === 0 && isAbsolute) {
+        ret.base = ret.name = path.slice(1, end);
+      } else {
+        ret.base = ret.name = path.slice(startPart, end);
+      }
+    }
+  } else {
+    if (startPart === 0 && isAbsolute) {
+      ret.name = path.slice(1, startDot);
+      ret.base = path.slice(1, end);
+    } else {
+      ret.name = path.slice(startPart, startDot);
+      ret.base = path.slice(startPart, end);
+    }
+    ret.ext = path.slice(startDot, end);
+  }
+
+  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute) ret.dir = "/";
+
+  return ret;
+}
+
+/**
+ * Converts a file URL to a path string.
+ *
+ *      fromFileUrl("file:///home/foo"); // "/home/foo"
+ * @param url of a file URL
+ */
+export function fromFileUrl(url: string | URL): string {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol != "file:") {
+    throw new TypeError("Must be a file URL.");
+  }
+  return decodeURIComponent(
+    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25"),
+  );
+}
+
+/**
+ * Converts a path string to a file URL.
+ *
+ *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
+ * @param path to convert to file URL
+ */
+export function toFileUrl(path: string): URL {
+  if (!isAbsolute(path)) {
+    throw new TypeError("Must be an absolute path.");
+  }
+  const url = new URL("file:///");
+  url.pathname = path.replace(/%/g, "%25").replace(/\\/g, "%5C");
+  return url;
+}

.deno/deps/https/deno.land/59e46148ccca57c14d2755561933862de4647177b1493b50d6963147427f5e11.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "vary": "Accept-Encoding, Origin",
+    "cache-control": "public, max-age=31536000, immutable",
+    "x-cache": "Hit from cloudfront",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "cross-origin-resource-policy": "same-origin",
+    "date": "Wed, 12 Oct 2022 22:13:12 GMT",
+    "etag": "\"faa8d08fd063480a5c14bc1bc60e9b57\"",
+    "x-content-type-options": "nosniff",
+    "via": "http/2 edgeproxy-h",
+    "age": "29184345",
+    "content-type": "application/typescript; charset=utf-8",
+    "access-control-allow-origin": "*",
+    "cross-origin-embedder-policy": "same-origin",
+    "x-amz-version-id": "UPxGV9Qf1JI1wlLizoi066FkMMQXAppy",
+    "server": "deno/gcp-us-west1",
+    "x-amz-cf-pop": "SEA73-P3",
+    "last-modified": "Wed, 20 Jan 2021 05:26:04 GMT",
+    "cross-origin-opener-policy": "same-origin",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-amz-cf-id": "m7seaG6hYMPHHujWXUhLF3B8U9YWSyu_eAv5WuZINclEIsVSiMju-w==",
+    "content-length": "14572",
+    "accept-ranges": "bytes",
+    "x-frame-options": "DENY",
+    "x-amz-replication-status": "FAILED",
+    "server-timing": "fetchSource;dur=38"
+  },
+  "url": "https://deno.land/std@0.84.0/path/posix.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 682144818
+  }
+}

.deno/deps/https/deno.land/678a5cff2d17fd224e1703f305e09ac8a2328bb71302e03665dcd871eb41c428

@@ -0,0 +1,387 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { osType } from "../_util/os.ts";
+import { join, normalize } from "./mod.ts";
+import { SEP, SEP_PATTERN } from "./separator.ts";
+
+export interface GlobOptions {
+  /** Extended glob syntax.
+   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults
+   * to true. */
+  extended?: boolean;
+  /** Globstar syntax.
+   * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+   * If false, `**` is treated like `*`. Defaults to true. */
+  globstar?: boolean;
+  /** Operating system. Defaults to the native OS. */
+  os?: typeof Deno.build.os;
+}
+
+export type GlobToRegExpOptions = GlobOptions;
+
+// deno-fmt-ignore
+const regExpEscapeChars = ["!", "$", "(", ")", "*", "+", ".", "=", "?", "[", "\\", "^", "{", "|"];
+const rangeEscapeChars = ["-", "\\", "]"];
+
+/** Convert a glob string to a regular expression.
+ *
+ * Tries to match bash glob expansion as closely as possible.
+ *
+ * Basic glob syntax:
+ * - `*` - Matches everything without leaving the path segment.
+ * - `{foo,bar}` - Matches `foo` or `bar`.
+ * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
+ * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
+ * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
+ * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
+ *     - `[[:alnum:]]` - Matches any digit or letter.
+ *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
+ *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
+ *       for a complete list of supported character classes.
+ * - `\` - Escapes the next character for an `os` other than `"windows"`.
+ * - \` - Escapes the next character for `os` set to `"windows"`.
+ * - `/` - Path separator.
+ * - `\` - Additional path separator only for `os` set to `"windows"`.
+ *
+ * Extended syntax:
+ * - Requires `{ extended: true }`.
+ * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
+ * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
+ * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
+ * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
+ * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
+ * - See https://www.linuxjournal.com/content/bash-extended-globbing.
+ *
+ * Globstar syntax:
+ * - Requires `{ globstar: true }`.
+ * - `**` - Matches any number of any path segments.
+ *     - Must comprise its entire path segment in the provided glob.
+ * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
+ *
+ * Note the following properties:
+ * - The generated `RegExp` is anchored at both start and end.
+ * - Repeating and trailing separators are tolerated. Trailing separators in the
+ *   provided glob have no meaning and are discarded.
+ * - Absolute globs will only match absolute paths, etc.
+ * - Empty globs will match nothing.
+ * - Any special glob syntax must be contained to one path segment. For example,
+ *   `?(foo|bar/baz)` is invalid. The separator will take precendence and the
+ *   first segment ends with an unclosed group.
+ * - If a path segment ends with unclosed groups or a dangling escape prefix, a
+ *   parse error has occured. Every character for that segment is taken
+ *   literally in this event.
+ *
+ * Limitations:
+ * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
+ *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
+ *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
+ *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
+ *   the group occurs not nested at the end of the segment. */
+export function globToRegExp(
+  glob: string,
+  { extended = true, globstar: globstarOption = true, os = osType }:
+    GlobToRegExpOptions = {},
+): RegExp {
+  if (glob == "") {
+    return /(?!)/;
+  }
+
+  const sep = os == "windows" ? "(?:\\\\|/)+" : "/+";
+  const sepMaybe = os == "windows" ? "(?:\\\\|/)*" : "/*";
+  const seps = os == "windows" ? ["\\", "/"] : ["/"];
+  const globstar = os == "windows"
+    ? "(?:[^\\\\/]*(?:\\\\|/|$)+)*"
+    : "(?:[^/]*(?:/|$)+)*";
+  const wildcard = os == "windows" ? "[^\\\\/]*" : "[^/]*";
+  const escapePrefix = os == "windows" ? "`" : "\\";
+
+  // Remove trailing separators.
+  let newLength = glob.length;
+  for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--);
+  glob = glob.slice(0, newLength);
+
+  let regExpString = "";
+
+  // Terminates correctly. Trust that `j` is incremented every iteration.
+  for (let j = 0; j < glob.length;) {
+    let segment = "";
+    const groupStack = [];
+    let inRange = false;
+    let inEscape = false;
+    let endsWithSep = false;
+    let i = j;
+
+    // Terminates with `i` at the non-inclusive end of the current segment.
+    for (; i < glob.length && !seps.includes(glob[i]); i++) {
+      if (inEscape) {
+        inEscape = false;
+        const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;
+        segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+        continue;
+      }
+
+      if (glob[i] == escapePrefix) {
+        inEscape = true;
+        continue;
+      }
+
+      if (glob[i] == "[") {
+        if (!inRange) {
+          inRange = true;
+          segment += "[";
+          if (glob[i + 1] == "!") {
+            i++;
+            segment += "^";
+          } else if (glob[i + 1] == "^") {
+            i++;
+            segment += "\\^";
+          }
+          continue;
+        } else if (glob[i + 1] == ":") {
+          let k = i + 1;
+          let value = "";
+          while (glob[k + 1] != null && glob[k + 1] != ":") {
+            value += glob[k + 1];
+            k++;
+          }
+          if (glob[k + 1] == ":" && glob[k + 2] == "]") {
+            i = k + 2;
+            if (value == "alnum") segment += "\\dA-Za-z";
+            else if (value == "alpha") segment += "A-Za-z";
+            else if (value == "ascii") segment += "\x00-\x7F";
+            else if (value == "blank") segment += "\t ";
+            else if (value == "cntrl") segment += "\x00-\x1F\x7F";
+            else if (value == "digit") segment += "\\d";
+            else if (value == "graph") segment += "\x21-\x7E";
+            else if (value == "lower") segment += "a-z";
+            else if (value == "print") segment += "\x20-\x7E";
+            else if (value == "punct") {
+              segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~";
+            } else if (value == "space") segment += "\\s\v";
+            else if (value == "upper") segment += "A-Z";
+            else if (value == "word") segment += "\\w";
+            else if (value == "xdigit") segment += "\\dA-Fa-f";
+            continue;
+          }
+        }
+      }
+
+      if (glob[i] == "]" && inRange) {
+        inRange = false;
+        segment += "]";
+        continue;
+      }
+
+      if (inRange) {
+        if (glob[i] == "\\") {
+          segment += `\\\\`;
+        } else {
+          segment += glob[i];
+        }
+        continue;
+      }
+
+      if (
+        glob[i] == ")" && groupStack.length > 0 &&
+        groupStack[groupStack.length - 1] != "BRACE"
+      ) {
+        segment += ")";
+        const type = groupStack.pop()!;
+        if (type == "!") {
+          segment += wildcard;
+        } else if (type != "@") {
+          segment += type;
+        }
+        continue;
+      }
+
+      if (
+        glob[i] == "|" && groupStack.length > 0 &&
+        groupStack[groupStack.length - 1] != "BRACE"
+      ) {
+        segment += "|";
+        continue;
+      }
+
+      if (glob[i] == "+" && extended && glob[i + 1] == "(") {
+        i++;
+        groupStack.push("+");
+        segment += "(?:";
+        continue;
+      }
+
+      if (glob[i] == "@" && extended && glob[i + 1] == "(") {
+        i++;
+        groupStack.push("@");
+        segment += "(?:";
+        continue;
+      }
+
+      if (glob[i] == "?") {
+        if (extended && glob[i + 1] == "(") {
+          i++;
+          groupStack.push("?");
+          segment += "(?:";
+        } else {
+          segment += ".";
+        }
+        continue;
+      }
+
+      if (glob[i] == "!" && extended && glob[i + 1] == "(") {
+        i++;
+        groupStack.push("!");
+        segment += "(?!";
+        continue;
+      }
+
+      if (glob[i] == "{") {
+        groupStack.push("BRACE");
+        segment += "(?:";
+        continue;
+      }
+
+      if (glob[i] == "}" && groupStack[groupStack.length - 1] == "BRACE") {
+        groupStack.pop();
+        segment += ")";
+        continue;
+      }
+
+      if (glob[i] == "," && groupStack[groupStack.length - 1] == "BRACE") {
+        segment += "|";
+        continue;
+      }
+
+      if (glob[i] == "*") {
+        if (extended && glob[i + 1] == "(") {
+          i++;
+          groupStack.push("*");
+          segment += "(?:";
+        } else {
+          const prevChar = glob[i - 1];
+          let numStars = 1;
+          while (glob[i + 1] == "*") {
+            i++;
+            numStars++;
+          }
+          const nextChar = glob[i + 1];
+          if (
+            globstarOption && numStars == 2 &&
+            [...seps, undefined].includes(prevChar) &&
+            [...seps, undefined].includes(nextChar)
+          ) {
+            segment += globstar;
+            endsWithSep = true;
+          } else {
+            segment += wildcard;
+          }
+        }
+        continue;
+      }
+
+      segment += regExpEscapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i];
+    }
+
+    // Check for unclosed groups or a dangling backslash.
+    if (groupStack.length > 0 || inRange || inEscape) {
+      // Parse failure. Take all characters from this segment literally.
+      segment = "";
+      for (const c of glob.slice(j, i)) {
+        segment += regExpEscapeChars.includes(c) ? `\\${c}` : c;
+        endsWithSep = false;
+      }
+    }
+
+    regExpString += segment;
+    if (!endsWithSep) {
+      regExpString += i < glob.length ? sep : sepMaybe;
+      endsWithSep = true;
+    }
+
+    // Terminates with `i` at the start of the next segment.
+    while (seps.includes(glob[i])) i++;
+
+    // Check that the next value of `j` is indeed higher than the current value.
+    if (!(i > j)) {
+      throw new Error("Assertion failure: i > j (potential infinite loop)");
+    }
+    j = i;
+  }
+
+  regExpString = `^${regExpString}$`;
+  return new RegExp(regExpString);
+}
+
+/** Test whether the given string is a glob */
+export function isGlob(str: string): boolean {
+  const chars: Record<string, string> = { "{": "}", "(": ")", "[": "]" };
+  const regex =
+    /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
+
+  if (str === "") {
+    return false;
+  }
+
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(str))) {
+    if (match[2]) return true;
+    let idx = match.index + match[0].length;
+
+    // if an open bracket/brace/paren is escaped,
+    // set the index to the next closing character
+    const open = match[1];
+    const close = open ? chars[open] : null;
+    if (open && close) {
+      const n = str.indexOf(close, idx);
+      if (n !== -1) {
+        idx = n + 1;
+      }
+    }
+
+    str = str.slice(idx);
+  }
+
+  return false;
+}
+
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function normalizeGlob(
+  glob: string,
+  { globstar = false }: GlobOptions = {},
+): string {
+  if (glob.match(/\0/g)) {
+    throw new Error(`Glob contains invalid characters: "${glob}"`);
+  }
+  if (!globstar) {
+    return normalize(glob);
+  }
+  const s = SEP_PATTERN.source;
+  const badParentPattern = new RegExp(
+    `(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`,
+    "g",
+  );
+  return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+}
+
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function joinGlobs(
+  globs: string[],
+  { extended = false, globstar = false }: GlobOptions = {},
+): string {
+  if (!globstar || globs.length == 0) {
+    return join(...globs);
+  }
+  if (globs.length === 0) return ".";
+  let joined: string | undefined;
+  for (const glob of globs) {
+    const path = glob;
+    if (path.length > 0) {
+      if (!joined) joined = path;
+      else joined += `${SEP}${path}`;
+    }
+  }
+  if (!joined) return ".";
+  return normalizeGlob(joined, { extended, globstar });
+}

.deno/deps/https/deno.land/678a5cff2d17fd224e1703f305e09ac8a2328bb71302e03665dcd871eb41c428.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "x-amz-cf-pop": "SEA73-P3",
+    "server-timing": "fetchSource;dur=14",
+    "cache-control": "public, max-age=31536000, immutable",
+    "x-amz-replication-status": "FAILED",
+    "x-frame-options": "DENY",
+    "x-amz-version-id": "vHtYhG1CnWUnUwNgbVRHJTKvZslqEuJH",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "content-length": "12303",
+    "access-control-allow-origin": "*",
+    "server": "deno/gcp-us-west1",
+    "x-cache": "Hit from cloudfront",
+    "cross-origin-embedder-policy": "same-origin",
+    "date": "Fri, 28 Oct 2022 13:44:31 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "x-content-type-options": "nosniff",
+    "last-modified": "Fri, 02 Apr 2021 05:03:20 GMT",
+    "cross-origin-resource-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "cross-origin-opener-policy": "same-origin",
+    "accept-ranges": "bytes",
+    "age": "27832465",
+    "content-type": "application/typescript; charset=utf-8",
+    "etag": "\"caf72ec6d39c7a17de71b1d3b14fdd7d\"",
+    "x-amz-cf-id": "Eeeotffcemjc9CNuIuCu2oiHJVI_jYg0M4grSlYc_rNTJbcxIGltlg==",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "via": "http/2 edgeproxy-h"
+  },
+  "url": "https://deno.land/std@0.92.0/path/glob.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 856488289
+  }
+}

.deno/deps/https/deno.land/68c0328e6ee41a9088cacf7c7ec358c0b7e757cf39291f2273f4b8d7950e2185

@@ -0,0 +1,381 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+import { BufReader, BufWriter } from "../io/bufio.ts";
+import { TextProtoReader } from "../textproto/mod.ts";
+import { assert } from "../_util/assert.ts";
+import { Response, ServerRequest } from "./server.ts";
+import { STATUS_TEXT } from "./http_status.ts";
+
+const encoder = new TextEncoder();
+
+export function emptyReader(): Deno.Reader {
+  return {
+    read(_: Uint8Array): Promise<number | null> {
+      return Promise.resolve(null);
+    },
+  };
+}
+
+export function bodyReader(contentLength: number, r: BufReader): Deno.Reader {
+  let totalRead = 0;
+  let finished = false;
+  async function read(buf: Uint8Array): Promise<number | null> {
+    if (finished) return null;
+    let result: number | null;
+    const remaining = contentLength - totalRead;
+    if (remaining >= buf.byteLength) {
+      result = await r.read(buf);
+    } else {
+      const readBuf = buf.subarray(0, remaining);
+      result = await r.read(readBuf);
+    }
+    if (result !== null) {
+      totalRead += result;
+    }
+    finished = totalRead === contentLength;
+    return result;
+  }
+  return { read };
+}
+
+export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader {
+  // Based on https://tools.ietf.org/html/rfc2616#section-19.4.6
+  const tp = new TextProtoReader(r);
+  let finished = false;
+  const chunks: Array<{
+    offset: number;
+    data: Uint8Array;
+  }> = [];
+  async function read(buf: Uint8Array): Promise<number | null> {
+    if (finished) return null;
+    const [chunk] = chunks;
+    if (chunk) {
+      const chunkRemaining = chunk.data.byteLength - chunk.offset;
+      const readLength = Math.min(chunkRemaining, buf.byteLength);
+      for (let i = 0; i < readLength; i++) {
+        buf[i] = chunk.data[chunk.offset + i];
+      }
+      chunk.offset += readLength;
+      if (chunk.offset === chunk.data.byteLength) {
+        chunks.shift();
+        // Consume \r\n;
+        if ((await tp.readLine()) === null) {
+          throw new Deno.errors.UnexpectedEof();
+        }
+      }
+      return readLength;
+    }
+    const line = await tp.readLine();
+    if (line === null) throw new Deno.errors.UnexpectedEof();
+    // TODO(bartlomieju): handle chunk extension
+    const [chunkSizeString] = line.split(";");
+    const chunkSize = parseInt(chunkSizeString, 16);
+    if (Number.isNaN(chunkSize) || chunkSize < 0) {
+      throw new Deno.errors.InvalidData("Invalid chunk size");
+    }
+    if (chunkSize > 0) {
+      if (chunkSize > buf.byteLength) {
+        let eof = await r.readFull(buf);
+        if (eof === null) {
+          throw new Deno.errors.UnexpectedEof();
+        }
+        const restChunk = new Uint8Array(chunkSize - buf.byteLength);
+        eof = await r.readFull(restChunk);
+        if (eof === null) {
+          throw new Deno.errors.UnexpectedEof();
+        } else {
+          chunks.push({
+            offset: 0,
+            data: restChunk,
+          });
+        }
+        return buf.byteLength;
+      } else {
+        const bufToFill = buf.subarray(0, chunkSize);
+        const eof = await r.readFull(bufToFill);
+        if (eof === null) {
+          throw new Deno.errors.UnexpectedEof();
+        }
+        // Consume \r\n
+        if ((await tp.readLine()) === null) {
+          throw new Deno.errors.UnexpectedEof();
+        }
+        return chunkSize;
+      }
+    } else {
+      assert(chunkSize === 0);
+      // Consume \r\n
+      if ((await r.readLine()) === null) {
+        throw new Deno.errors.UnexpectedEof();
+      }
+      await readTrailers(h, r);
+      finished = true;
+      return null;
+    }
+  }
+  return { read };
+}
+
+function isProhibidedForTrailer(key: string): boolean {
+  const s = new Set(["transfer-encoding", "content-length", "trailer"]);
+  return s.has(key.toLowerCase());
+}
+
+/** Read trailer headers from reader and append values to headers. "trailer"
+ * field will be deleted. */
+export async function readTrailers(
+  headers: Headers,
+  r: BufReader,
+): Promise<void> {
+  const trailers = parseTrailer(headers.get("trailer"));
+  if (trailers == null) return;
+  const trailerNames = [...trailers.keys()];
+  const tp = new TextProtoReader(r);
+  const result = await tp.readMIMEHeader();
+  if (result == null) {
+    throw new Deno.errors.InvalidData("Missing trailer header.");
+  }
+  const undeclared = [...result.keys()].filter(
+    (k) => !trailerNames.includes(k),
+  );
+  if (undeclared.length > 0) {
+    throw new Deno.errors.InvalidData(
+      `Undeclared trailers: ${Deno.inspect(undeclared)}.`,
+    );
+  }
+  for (const [k, v] of result) {
+    headers.append(k, v);
+  }
+  const missingTrailers = trailerNames.filter((k) => !result.has(k));
+  if (missingTrailers.length > 0) {
+    throw new Deno.errors.InvalidData(
+      `Missing trailers: ${Deno.inspect(missingTrailers)}.`,
+    );
+  }
+  headers.delete("trailer");
+}
+
+function parseTrailer(field: string | null): Headers | undefined {
+  if (field == null) {
+    return undefined;
+  }
+  const trailerNames = field.split(",").map((v) => v.trim().toLowerCase());
+  if (trailerNames.length === 0) {
+    throw new Deno.errors.InvalidData("Empty trailer header.");
+  }
+  const prohibited = trailerNames.filter((k) => isProhibidedForTrailer(k));
+  if (prohibited.length > 0) {
+    throw new Deno.errors.InvalidData(
+      `Prohibited trailer names: ${Deno.inspect(prohibited)}.`,
+    );
+  }
+  return new Headers(trailerNames.map((key) => [key, ""]));
+}
+
+export async function writeChunkedBody(
+  w: BufWriter,
+  r: Deno.Reader,
+): Promise<void> {
+  for await (const chunk of Deno.iter(r)) {
+    if (chunk.byteLength <= 0) continue;
+    const start = encoder.encode(`${chunk.byteLength.toString(16)}\r\n`);
+    const end = encoder.encode("\r\n");
+    await w.write(start);
+    await w.write(chunk);
+    await w.write(end);
+    await w.flush();
+  }
+
+  const endChunk = encoder.encode("0\r\n\r\n");
+  await w.write(endChunk);
+}
+
+/** Write trailer headers to writer. It should mostly should be called after
+ * `writeResponse()`. */
+export async function writeTrailers(
+  w: Deno.Writer,
+  headers: Headers,
+  trailers: Headers,
+): Promise<void> {
+  const trailer = headers.get("trailer");
+  if (trailer === null) {
+    throw new TypeError("Missing trailer header.");
+  }
+  const transferEncoding = headers.get("transfer-encoding");
+  if (transferEncoding === null || !transferEncoding.match(/^chunked/)) {
+    throw new TypeError(
+      `Trailers are only allowed for "transfer-encoding: chunked", got "transfer-encoding: ${transferEncoding}".`,
+    );
+  }
+  const writer = BufWriter.create(w);
+  const trailerNames = trailer.split(",").map((s) => s.trim().toLowerCase());
+  const prohibitedTrailers = trailerNames.filter((k) =>
+    isProhibidedForTrailer(k)
+  );
+  if (prohibitedTrailers.length > 0) {
+    throw new TypeError(
+      `Prohibited trailer names: ${Deno.inspect(prohibitedTrailers)}.`,
+    );
+  }
+  const undeclared = [...trailers.keys()].filter(
+    (k) => !trailerNames.includes(k),
+  );
+  if (undeclared.length > 0) {
+    throw new TypeError(`Undeclared trailers: ${Deno.inspect(undeclared)}.`);
+  }
+  for (const [key, value] of trailers) {
+    await writer.write(encoder.encode(`${key}: ${value}\r\n`));
+  }
+  await writer.write(encoder.encode("\r\n"));
+  await writer.flush();
+}
+
+export async function writeResponse(
+  w: Deno.Writer,
+  r: Response,
+): Promise<void> {
+  const protoMajor = 1;
+  const protoMinor = 1;
+  const statusCode = r.status || 200;
+  const statusText = STATUS_TEXT.get(statusCode);
+  const writer = BufWriter.create(w);
+  if (!statusText) {
+    throw new Deno.errors.InvalidData("Bad status code");
+  }
+  if (!r.body) {
+    r.body = new Uint8Array();
+  }
+  if (typeof r.body === "string") {
+    r.body = encoder.encode(r.body);
+  }
+
+  let out = `HTTP/${protoMajor}.${protoMinor} ${statusCode} ${statusText}\r\n`;
+
+  const headers = r.headers ?? new Headers();
+
+  if (r.body && !headers.get("content-length")) {
+    if (r.body instanceof Uint8Array) {
+      out += `content-length: ${r.body.byteLength}\r\n`;
+    } else if (!headers.get("transfer-encoding")) {
+      out += "transfer-encoding: chunked\r\n";
+    }
+  }
+
+  for (const [key, value] of headers) {
+    out += `${key}: ${value}\r\n`;
+  }
+
+  out += `\r\n`;
+
+  const header = encoder.encode(out);
+  const n = await writer.write(header);
+  assert(n === header.byteLength);
+
+  if (r.body instanceof Uint8Array) {
+    const n = await writer.write(r.body);
+    assert(n === r.body.byteLength);
+  } else if (headers.has("content-length")) {
+    const contentLength = headers.get("content-length");
+    assert(contentLength != null);
+    const bodyLength = parseInt(contentLength);
+    const n = await Deno.copy(r.body, writer);
+    assert(n === bodyLength);
+  } else {
+    await writeChunkedBody(writer, r.body);
+  }
+  if (r.trailers) {
+    const t = await r.trailers();
+    await writeTrailers(writer, headers, t);
+  }
+  await writer.flush();
+}
+
+/**
+ * ParseHTTPVersion parses a HTTP version string.
+ * "HTTP/1.0" returns (1, 0).
+ * Ported from https://github.com/golang/go/blob/f5c43b9/src/net/http/request.go#L766-L792
+ */
+export function parseHTTPVersion(vers: string): [number, number] {
+  switch (vers) {
+    case "HTTP/1.1":
+      return [1, 1];
+
+    case "HTTP/1.0":
+      return [1, 0];
+
+    default: {
+      const Big = 1000000; // arbitrary upper bound
+
+      if (!vers.startsWith("HTTP/")) {
+        break;
+      }
+
+      const dot = vers.indexOf(".");
+      if (dot < 0) {
+        break;
+      }
+
+      const majorStr = vers.substring(vers.indexOf("/") + 1, dot);
+      const major = Number(majorStr);
+      if (!Number.isInteger(major) || major < 0 || major > Big) {
+        break;
+      }
+
+      const minorStr = vers.substring(dot + 1);
+      const minor = Number(minorStr);
+      if (!Number.isInteger(minor) || minor < 0 || minor > Big) {
+        break;
+      }
+
+      return [major, minor];
+    }
+  }
+
+  throw new Error(`malformed HTTP version ${vers}`);
+}
+
+export async function readRequest(
+  conn: Deno.Conn,
+  bufr: BufReader,
+): Promise<ServerRequest | null> {
+  const tp = new TextProtoReader(bufr);
+  const firstLine = await tp.readLine(); // e.g. GET /index.html HTTP/1.0
+  if (firstLine === null) return null;
+  const headers = await tp.readMIMEHeader();
+  if (headers === null) throw new Deno.errors.UnexpectedEof();
+
+  const req = new ServerRequest();
+  req.conn = conn;
+  req.r = bufr;
+  [req.method, req.url, req.proto] = firstLine.split(" ", 3);
+  [req.protoMajor, req.protoMinor] = parseHTTPVersion(req.proto);
+  req.headers = headers;
+  fixLength(req);
+  return req;
+}
+
+function fixLength(req: ServerRequest): void {
+  const contentLength = req.headers.get("Content-Length");
+  if (contentLength) {
+    const arrClen = contentLength.split(",");
+    if (arrClen.length > 1) {
+      const distinct = [...new Set(arrClen.map((e): string => e.trim()))];
+      if (distinct.length > 1) {
+        throw Error("cannot contain multiple Content-Length headers");
+      } else {
+        req.headers.set("Content-Length", distinct[0]);
+      }
+    }
+    const c = req.headers.get("Content-Length");
+    if (req.method === "HEAD" && c && c !== "0") {
+      throw Error("http: method cannot contain a Content-Length");
+    }
+    if (c && req.headers.has("transfer-encoding")) {
+      // A sender MUST NOT send a Content-Length header field in any message
+      // that contains a Transfer-Encoding header field.
+      // rfc: https://tools.ietf.org/html/rfc7230#section-3.3.2
+      throw new Error(
+        "http: Transfer-Encoding and Content-Length cannot be send together",
+      );
+    }
+  }
+}

.deno/deps/https/deno.land/68c0328e6ee41a9088cacf7c7ec358c0b7e757cf39291f2273f4b8d7950e2185.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "x-amz-cf-pop": "SEA73-P3",
+    "server": "deno/gcp-us-west1",
+    "server-timing": "fetchSource;dur=12",
+    "date": "Mon, 04 Sep 2023 17:52:41 GMT",
+    "x-content-type-options": "nosniff",
+    "cross-origin-resource-policy": "same-origin",
+    "etag": "\"ad756cb543f4575718c3a72164134f37\"",
+    "content-type": "application/typescript; charset=utf-8",
+    "vary": "Accept-Encoding, Origin",
+    "x-amz-version-id": "E4k6O3yOBIgsv9OsiMlAdsIeqOLIMlah",
+    "access-control-allow-origin": "*",
+    "age": "947175",
+    "x-amz-replication-status": "COMPLETED",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "cross-origin-embedder-policy": "same-origin",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "via": "http/2 edgeproxy-h",
+    "content-length": "11578",
+    "x-frame-options": "DENY",
+    "accept-ranges": "bytes",
+    "cross-origin-opener-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-cf-id": "2OJemX1uBy4x1KJcOAgj7Rby4anC6FOb6H4QgOnS_vyNjE9VQnGMww==",
+    "x-cache": "Hit from cloudfront",
+    "last-modified": "Fri, 02 Apr 2021 05:03:19 GMT",
+    "cache-control": "public, max-age=31536000, immutable"
+  },
+  "url": "https://deno.land/std@0.92.0/http/_io.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 969905149
+  }
+}

.deno/deps/https/deno.land/6b53dbda29cf8186bf78dc67d9f2b44c60d22f4d20d66dccce32493e9c631b18

@@ -0,0 +1,720 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// Based on https://github.com/golang/go/blob/891682/src/bufio/bufio.go
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+type Reader = Deno.Reader;
+type Writer = Deno.Writer;
+type WriterSync = Deno.WriterSync;
+import { copy } from "../bytes/mod.ts";
+import { assert } from "../_util/assert.ts";
+import { Buffer } from "./buffer.ts";
+import { writeAll, writeAllSync } from "./util.ts";
+
+const DEFAULT_BUF_SIZE = 4096;
+const MIN_BUF_SIZE = 16;
+const MAX_CONSECUTIVE_EMPTY_READS = 100;
+const CR = "\r".charCodeAt(0);
+const LF = "\n".charCodeAt(0);
+
+export class BufferFullError extends Error {
+  name = "BufferFullError";
+  constructor(public partial: Uint8Array) {
+    super("Buffer full");
+  }
+}
+
+export class PartialReadError extends Error {
+  name = "PartialReadError";
+  partial?: Uint8Array;
+  constructor() {
+    super("Encountered UnexpectedEof, data only partially read");
+  }
+}
+
+/** Result type returned by of BufReader.readLine(). */
+export interface ReadLineResult {
+  line: Uint8Array;
+  more: boolean;
+}
+
+/** BufReader implements buffering for a Reader object. */
+export class BufReader implements Reader {
+  private buf!: Uint8Array;
+  private rd!: Reader; // Reader provided by caller.
+  private r = 0; // buf read position.
+  private w = 0; // buf write position.
+  private eof = false;
+  // private lastByte: number;
+  // private lastCharSize: number;
+
+  /** return new BufReader unless r is BufReader */
+  static create(r: Reader, size: number = DEFAULT_BUF_SIZE): BufReader {
+    return r instanceof BufReader ? r : new BufReader(r, size);
+  }
+
+  constructor(rd: Reader, size: number = DEFAULT_BUF_SIZE) {
+    if (size < MIN_BUF_SIZE) {
+      size = MIN_BUF_SIZE;
+    }
+    this._reset(new Uint8Array(size), rd);
+  }
+
+  /** Returns the size of the underlying buffer in bytes. */
+  size(): number {
+    return this.buf.byteLength;
+  }
+
+  buffered(): number {
+    return this.w - this.r;
+  }
+
+  // Reads a new chunk into the buffer.
+  private async _fill(): Promise<void> {
+    // Slide existing data to beginning.
+    if (this.r > 0) {
+      this.buf.copyWithin(0, this.r, this.w);
+      this.w -= this.r;
+      this.r = 0;
+    }
+
+    if (this.w >= this.buf.byteLength) {
+      throw Error("bufio: tried to fill full buffer");
+    }
+
+    // Read new data: try a limited number of times.
+    for (let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--) {
+      const rr = await this.rd.read(this.buf.subarray(this.w));
+      if (rr === null) {
+        this.eof = true;
+        return;
+      }
+      assert(rr >= 0, "negative read");
+      this.w += rr;
+      if (rr > 0) {
+        return;
+      }
+    }
+
+    throw new Error(
+      `No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`,
+    );
+  }
+
+  /** Discards any buffered data, resets all state, and switches
+   * the buffered reader to read from r.
+   */
+  reset(r: Reader): void {
+    this._reset(this.buf, r);
+  }
+
+  private _reset(buf: Uint8Array, rd: Reader): void {
+    this.buf = buf;
+    this.rd = rd;
+    this.eof = false;
+    // this.lastByte = -1;
+    // this.lastCharSize = -1;
+  }
+
+  /** reads data into p.
+   * It returns the number of bytes read into p.
+   * The bytes are taken from at most one Read on the underlying Reader,
+   * hence n may be less than len(p).
+   * To read exactly len(p) bytes, use io.ReadFull(b, p).
+   */
+  async read(p: Uint8Array): Promise<number | null> {
+    let rr: number | null = p.byteLength;
+    if (p.byteLength === 0) return rr;
+
+    if (this.r === this.w) {
+      if (p.byteLength >= this.buf.byteLength) {
+        // Large read, empty buffer.
+        // Read directly into p to avoid copy.
+        const rr = await this.rd.read(p);
+        const nread = rr ?? 0;
+        assert(nread >= 0, "negative read");
+        // if (rr.nread > 0) {
+        //   this.lastByte = p[rr.nread - 1];
+        //   this.lastCharSize = -1;
+        // }
+        return rr;
+      }
+
+      // One read.
+      // Do not use this.fill, which will loop.
+      this.r = 0;
+      this.w = 0;
+      rr = await this.rd.read(this.buf);
+      if (rr === 0 || rr === null) return rr;
+      assert(rr >= 0, "negative read");
+      this.w += rr;
+    }
+
+    // copy as much as we can
+    const copied = copy(this.buf.subarray(this.r, this.w), p, 0);
+    this.r += copied;
+    // this.lastByte = this.buf[this.r - 1];
+    // this.lastCharSize = -1;
+    return copied;
+  }
+
+  /** reads exactly `p.length` bytes into `p`.
+   *
+   * If successful, `p` is returned.
+   *
+   * If the end of the underlying stream has been reached, and there are no more
+   * bytes available in the buffer, `readFull()` returns `null` instead.
+   *
+   * An error is thrown if some bytes could be read, but not enough to fill `p`
+   * entirely before the underlying stream reported an error or EOF. Any error
+   * thrown will have a `partial` property that indicates the slice of the
+   * buffer that has been successfully filled with data.
+   *
+   * Ported from https://golang.org/pkg/io/#ReadFull
+   */
+  async readFull(p: Uint8Array): Promise<Uint8Array | null> {
+    let bytesRead = 0;
+    while (bytesRead < p.length) {
+      try {
+        const rr = await this.read(p.subarray(bytesRead));
+        if (rr === null) {
+          if (bytesRead === 0) {
+            return null;
+          } else {
+            throw new PartialReadError();
+          }
+        }
+        bytesRead += rr;
+      } catch (err) {
+        err.partial = p.subarray(0, bytesRead);
+        throw err;
+      }
+    }
+    return p;
+  }
+
+  /** Returns the next byte [0, 255] or `null`. */
+  async readByte(): Promise<number | null> {
+    while (this.r === this.w) {
+      if (this.eof) return null;
+      await this._fill(); // buffer is empty.
+    }
+    const c = this.buf[this.r];
+    this.r++;
+    // this.lastByte = c;
+    return c;
+  }
+
+  /** readString() reads until the first occurrence of delim in the input,
+   * returning a string containing the data up to and including the delimiter.
+   * If ReadString encounters an error before finding a delimiter,
+   * it returns the data read before the error and the error itself
+   * (often `null`).
+   * ReadString returns err != nil if and only if the returned data does not end
+   * in delim.
+   * For simple uses, a Scanner may be more convenient.
+   */
+  async readString(delim: string): Promise<string | null> {
+    if (delim.length !== 1) {
+      throw new Error("Delimiter should be a single character");
+    }
+    const buffer = await this.readSlice(delim.charCodeAt(0));
+    if (buffer === null) return null;
+    return new TextDecoder().decode(buffer);
+  }
+
+  /** `readLine()` is a low-level line-reading primitive. Most callers should
+   * use `readString('\n')` instead or use a Scanner.
+   *
+   * `readLine()` tries to return a single line, not including the end-of-line
+   * bytes. If the line was too long for the buffer then `more` is set and the
+   * beginning of the line is returned. The rest of the line will be returned
+   * from future calls. `more` will be false when returning the last fragment
+   * of the line. The returned buffer is only valid until the next call to
+   * `readLine()`.
+   *
+   * The text returned from ReadLine does not include the line end ("\r\n" or
+   * "\n").
+   *
+   * When the end of the underlying stream is reached, the final bytes in the
+   * stream are returned. No indication or error is given if the input ends
+   * without a final line end. When there are no more trailing bytes to read,
+   * `readLine()` returns `null`.
+   *
+   * Calling `unreadByte()` after `readLine()` will always unread the last byte
+   * read (possibly a character belonging to the line end) even if that byte is
+   * not part of the line returned by `readLine()`.
+   */
+  async readLine(): Promise<ReadLineResult | null> {
+    let line: Uint8Array | null;
+
+    try {
+      line = await this.readSlice(LF);
+    } catch (err) {
+      let { partial } = err;
+      assert(
+        partial instanceof Uint8Array,
+        "bufio: caught error from `readSlice()` without `partial` property",
+      );
+
+      // Don't throw if `readSlice()` failed with `BufferFullError`, instead we
+      // just return whatever is available and set the `more` flag.
+      if (!(err instanceof BufferFullError)) {
+        throw err;
+      }
+
+      // Handle the case where "\r\n" straddles the buffer.
+      if (
+        !this.eof &&
+        partial.byteLength > 0 &&
+        partial[partial.byteLength - 1] === CR
+      ) {
+        // Put the '\r' back on buf and drop it from line.
+        // Let the next call to ReadLine check for "\r\n".
+        assert(this.r > 0, "bufio: tried to rewind past start of buffer");
+        this.r--;
+        partial = partial.subarray(0, partial.byteLength - 1);
+      }
+
+      return { line: partial, more: !this.eof };
+    }
+
+    if (line === null) {
+      return null;
+    }
+
+    if (line.byteLength === 0) {
+      return { line, more: false };
+    }
+
+    if (line[line.byteLength - 1] == LF) {
+      let drop = 1;
+      if (line.byteLength > 1 && line[line.byteLength - 2] === CR) {
+        drop = 2;
+      }
+      line = line.subarray(0, line.byteLength - drop);
+    }
+    return { line, more: false };
+  }
+
+  /** `readSlice()` reads until the first occurrence of `delim` in the input,
+   * returning a slice pointing at the bytes in the buffer. The bytes stop
+   * being valid at the next read.
+   *
+   * If `readSlice()` encounters an error before finding a delimiter, or the
+   * buffer fills without finding a delimiter, it throws an error with a
+   * `partial` property that contains the entire buffer.
+   *
+   * If `readSlice()` encounters the end of the underlying stream and there are
+   * any bytes left in the buffer, the rest of the buffer is returned. In other
+   * words, EOF is always treated as a delimiter. Once the buffer is empty,
+   * it returns `null`.
+   *
+   * Because the data returned from `readSlice()` will be overwritten by the
+   * next I/O operation, most clients should use `readString()` instead.
+   */
+  async readSlice(delim: number): Promise<Uint8Array | null> {
+    let s = 0; // search start index
+    let slice: Uint8Array | undefined;
+
+    while (true) {
+      // Search buffer.
+      let i = this.buf.subarray(this.r + s, this.w).indexOf(delim);
+      if (i >= 0) {
+        i += s;
+        slice = this.buf.subarray(this.r, this.r + i + 1);
+        this.r += i + 1;
+        break;
+      }
+
+      // EOF?
+      if (this.eof) {
+        if (this.r === this.w) {
+          return null;
+        }
+        slice = this.buf.subarray(this.r, this.w);
+        this.r = this.w;
+        break;
+      }
+
+      // Buffer full?
+      if (this.buffered() >= this.buf.byteLength) {
+        this.r = this.w;
+        // #4521 The internal buffer should not be reused across reads because it causes corruption of data.
+        const oldbuf = this.buf;
+        const newbuf = this.buf.slice(0);
+        this.buf = newbuf;
+        throw new BufferFullError(oldbuf);
+      }
+
+      s = this.w - this.r; // do not rescan area we scanned before
+
+      // Buffer is not full.
+      try {
+        await this._fill();
+      } catch (err) {
+        err.partial = slice;
+        throw err;
+      }
+    }
+
+    // Handle last byte, if any.
+    // const i = slice.byteLength - 1;
+    // if (i >= 0) {
+    //   this.lastByte = slice[i];
+    //   this.lastCharSize = -1
+    // }
+
+    return slice;
+  }
+
+  /** `peek()` returns the next `n` bytes without advancing the reader. The
+   * bytes stop being valid at the next read call.
+   *
+   * When the end of the underlying stream is reached, but there are unread
+   * bytes left in the buffer, those bytes are returned. If there are no bytes
+   * left in the buffer, it returns `null`.
+   *
+   * If an error is encountered before `n` bytes are available, `peek()` throws
+   * an error with the `partial` property set to a slice of the buffer that
+   * contains the bytes that were available before the error occurred.
+   */
+  async peek(n: number): Promise<Uint8Array | null> {
+    if (n < 0) {
+      throw Error("negative count");
+    }
+
+    let avail = this.w - this.r;
+    while (avail < n && avail < this.buf.byteLength && !this.eof) {
+      try {
+        await this._fill();
+      } catch (err) {
+        err.partial = this.buf.subarray(this.r, this.w);
+        throw err;
+      }
+      avail = this.w - this.r;
+    }
+
+    if (avail === 0 && this.eof) {
+      return null;
+    } else if (avail < n && this.eof) {
+      return this.buf.subarray(this.r, this.r + avail);
+    } else if (avail < n) {
+      throw new BufferFullError(this.buf.subarray(this.r, this.w));
+    }
+
+    return this.buf.subarray(this.r, this.r + n);
+  }
+}
+
+abstract class AbstractBufBase {
+  buf!: Uint8Array;
+  usedBufferBytes = 0;
+  err: Error | null = null;
+
+  /** Size returns the size of the underlying buffer in bytes. */
+  size(): number {
+    return this.buf.byteLength;
+  }
+
+  /** Returns how many bytes are unused in the buffer. */
+  available(): number {
+    return this.buf.byteLength - this.usedBufferBytes;
+  }
+
+  /** buffered returns the number of bytes that have been written into the
+   * current buffer.
+   */
+  buffered(): number {
+    return this.usedBufferBytes;
+  }
+}
+
+/** BufWriter implements buffering for an deno.Writer object.
+ * If an error occurs writing to a Writer, no more data will be
+ * accepted and all subsequent writes, and flush(), will return the error.
+ * After all data has been written, the client should call the
+ * flush() method to guarantee all data has been forwarded to
+ * the underlying deno.Writer.
+ */
+export class BufWriter extends AbstractBufBase implements Writer {
+  /** return new BufWriter unless writer is BufWriter */
+  static create(writer: Writer, size: number = DEFAULT_BUF_SIZE): BufWriter {
+    return writer instanceof BufWriter ? writer : new BufWriter(writer, size);
+  }
+
+  constructor(private writer: Writer, size: number = DEFAULT_BUF_SIZE) {
+    super();
+    if (size <= 0) {
+      size = DEFAULT_BUF_SIZE;
+    }
+    this.buf = new Uint8Array(size);
+  }
+
+  /** Discards any unflushed buffered data, clears any error, and
+   * resets buffer to write its output to w.
+   */
+  reset(w: Writer): void {
+    this.err = null;
+    this.usedBufferBytes = 0;
+    this.writer = w;
+  }
+
+  /** Flush writes any buffered data to the underlying io.Writer. */
+  async flush(): Promise<void> {
+    if (this.err !== null) throw this.err;
+    if (this.usedBufferBytes === 0) return;
+
+    try {
+      await writeAll(
+        this.writer,
+        this.buf.subarray(0, this.usedBufferBytes),
+      );
+    } catch (e) {
+      this.err = e;
+      throw e;
+    }
+
+    this.buf = new Uint8Array(this.buf.length);
+    this.usedBufferBytes = 0;
+  }
+
+  /** Writes the contents of `data` into the buffer.  If the contents won't fully
+   * fit into the buffer, those bytes that can are copied into the buffer, the
+   * buffer is the flushed to the writer and the remaining bytes are copied into
+   * the now empty buffer.
+   *
+   * @return the number of bytes written to the buffer.
+   */
+  async write(data: Uint8Array): Promise<number> {
+    if (this.err !== null) throw this.err;
+    if (data.length === 0) return 0;
+
+    let totalBytesWritten = 0;
+    let numBytesWritten = 0;
+    while (data.byteLength > this.available()) {
+      if (this.buffered() === 0) {
+        // Large write, empty buffer.
+        // Write directly from data to avoid copy.
+        try {
+          numBytesWritten = await this.writer.write(data);
+        } catch (e) {
+          this.err = e;
+          throw e;
+        }
+      } else {
+        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);
+        this.usedBufferBytes += numBytesWritten;
+        await this.flush();
+      }
+      totalBytesWritten += numBytesWritten;
+      data = data.subarray(numBytesWritten);
+    }
+
+    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);
+    this.usedBufferBytes += numBytesWritten;
+    totalBytesWritten += numBytesWritten;
+    return totalBytesWritten;
+  }
+}
+
+/** BufWriterSync implements buffering for a deno.WriterSync object.
+ * If an error occurs writing to a WriterSync, no more data will be
+ * accepted and all subsequent writes, and flush(), will return the error.
+ * After all data has been written, the client should call the
+ * flush() method to guarantee all data has been forwarded to
+ * the underlying deno.WriterSync.
+ */
+export class BufWriterSync extends AbstractBufBase implements WriterSync {
+  /** return new BufWriterSync unless writer is BufWriterSync */
+  static create(
+    writer: WriterSync,
+    size: number = DEFAULT_BUF_SIZE,
+  ): BufWriterSync {
+    return writer instanceof BufWriterSync
+      ? writer
+      : new BufWriterSync(writer, size);
+  }
+
+  constructor(private writer: WriterSync, size: number = DEFAULT_BUF_SIZE) {
+    super();
+    if (size <= 0) {
+      size = DEFAULT_BUF_SIZE;
+    }
+    this.buf = new Uint8Array(size);
+  }
+
+  /** Discards any unflushed buffered data, clears any error, and
+   * resets buffer to write its output to w.
+   */
+  reset(w: WriterSync): void {
+    this.err = null;
+    this.usedBufferBytes = 0;
+    this.writer = w;
+  }
+
+  /** Flush writes any buffered data to the underlying io.WriterSync. */
+  flush(): void {
+    if (this.err !== null) throw this.err;
+    if (this.usedBufferBytes === 0) return;
+
+    try {
+      writeAllSync(
+        this.writer,
+        this.buf.subarray(0, this.usedBufferBytes),
+      );
+    } catch (e) {
+      this.err = e;
+      throw e;
+    }
+
+    this.buf = new Uint8Array(this.buf.length);
+    this.usedBufferBytes = 0;
+  }
+
+  /** Writes the contents of `data` into the buffer.  If the contents won't fully
+   * fit into the buffer, those bytes that can are copied into the buffer, the
+   * buffer is the flushed to the writer and the remaining bytes are copied into
+   * the now empty buffer.
+   *
+   * @return the number of bytes written to the buffer.
+   */
+  writeSync(data: Uint8Array): number {
+    if (this.err !== null) throw this.err;
+    if (data.length === 0) return 0;
+
+    let totalBytesWritten = 0;
+    let numBytesWritten = 0;
+    while (data.byteLength > this.available()) {
+      if (this.buffered() === 0) {
+        // Large write, empty buffer.
+        // Write directly from data to avoid copy.
+        try {
+          numBytesWritten = this.writer.writeSync(data);
+        } catch (e) {
+          this.err = e;
+          throw e;
+        }
+      } else {
+        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);
+        this.usedBufferBytes += numBytesWritten;
+        this.flush();
+      }
+      totalBytesWritten += numBytesWritten;
+      data = data.subarray(numBytesWritten);
+    }
+
+    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);
+    this.usedBufferBytes += numBytesWritten;
+    totalBytesWritten += numBytesWritten;
+    return totalBytesWritten;
+  }
+}
+
+/** Generate longest proper prefix which is also suffix array. */
+function createLPS(pat: Uint8Array): Uint8Array {
+  const lps = new Uint8Array(pat.length);
+  lps[0] = 0;
+  let prefixEnd = 0;
+  let i = 1;
+  while (i < lps.length) {
+    if (pat[i] == pat[prefixEnd]) {
+      prefixEnd++;
+      lps[i] = prefixEnd;
+      i++;
+    } else if (prefixEnd === 0) {
+      lps[i] = 0;
+      i++;
+    } else {
+      prefixEnd = pat[prefixEnd - 1];
+    }
+  }
+  return lps;
+}
+
+/** Read delimited bytes from a Reader. */
+export async function* readDelim(
+  reader: Reader,
+  delim: Uint8Array,
+): AsyncIterableIterator<Uint8Array> {
+  // Avoid unicode problems
+  const delimLen = delim.length;
+  const delimLPS = createLPS(delim);
+
+  let inputBuffer = new Buffer();
+  const inspectArr = new Uint8Array(Math.max(1024, delimLen + 1));
+
+  // Modified KMP
+  let inspectIndex = 0;
+  let matchIndex = 0;
+  while (true) {
+    const result = await reader.read(inspectArr);
+    if (result === null) {
+      // Yield last chunk.
+      yield inputBuffer.bytes();
+      return;
+    }
+    if ((result as number) < 0) {
+      // Discard all remaining and silently fail.
+      return;
+    }
+    const sliceRead = inspectArr.subarray(0, result as number);
+    await writeAll(inputBuffer, sliceRead);
+
+    let sliceToProcess = inputBuffer.bytes();
+    while (inspectIndex < sliceToProcess.length) {
+      if (sliceToProcess[inspectIndex] === delim[matchIndex]) {
+        inspectIndex++;
+        matchIndex++;
+        if (matchIndex === delimLen) {
+          // Full match
+          const matchEnd = inspectIndex - delimLen;
+          const readyBytes = sliceToProcess.subarray(0, matchEnd);
+          // Copy
+          const pendingBytes = sliceToProcess.slice(inspectIndex);
+          yield readyBytes;
+          // Reset match, different from KMP.
+          sliceToProcess = pendingBytes;
+          inspectIndex = 0;
+          matchIndex = 0;
+        }
+      } else {
+        if (matchIndex === 0) {
+          inspectIndex++;
+        } else {
+          matchIndex = delimLPS[matchIndex - 1];
+        }
+      }
+    }
+    // Keep inspectIndex and matchIndex.
+    inputBuffer = new Buffer(sliceToProcess);
+  }
+}
+
+/** Read delimited strings from a Reader. */
+export async function* readStringDelim(
+  reader: Reader,
+  delim: string,
+): AsyncIterableIterator<string> {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  for await (const chunk of readDelim(reader, encoder.encode(delim))) {
+    yield decoder.decode(chunk);
+  }
+}
+
+/** Read strings line-by-line from a Reader. */
+export async function* readLines(
+  reader: Reader,
+): AsyncIterableIterator<string> {
+  for await (let chunk of readStringDelim(reader, "\n")) {
+    // Finding a CR at the end of the line is evidence of a
+    // "\r\n" at the end of the line. The "\r" part should be
+    // removed too.
+    if (chunk.endsWith("\r")) {
+      chunk = chunk.slice(0, -1);
+    }
+    yield chunk;
+  }
+}

.deno/deps/https/deno.land/6b53dbda29cf8186bf78dc67d9f2b44c60d22f4d20d66dccce32493e9c631b18.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "access-control-allow-origin": "*",
+    "x-content-type-options": "nosniff",
+    "last-modified": "Fri, 02 Apr 2021 05:03:19 GMT",
+    "x-frame-options": "DENY",
+    "content-length": "21962",
+    "cross-origin-embedder-policy": "same-origin",
+    "server": "deno/gcp-us-west1",
+    "x-amz-replication-status": "FAILED",
+    "vary": "Accept-Encoding, Origin",
+    "age": "28911889",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "accept-ranges": "bytes",
+    "x-amz-cf-pop": "SEA73-P3",
+    "etag": "\"cbb89e0002be7a07066555cf1e7d3835\"",
+    "cross-origin-resource-policy": "same-origin",
+    "x-amz-version-id": "69Hwreb4GYd0JSntgnF2xVKzXXytMWDB",
+    "date": "Sun, 16 Oct 2022 01:54:07 GMT",
+    "via": "http/2 edgeproxy-h",
+    "server-timing": "fetchSource;dur=14",
+    "content-type": "application/typescript; charset=utf-8",
+    "cross-origin-opener-policy": "same-origin",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "x-amz-cf-id": "SpPPJR0A34_2JnUA0plzBf2zmtC_JHU-2AWxng7tn5maGzjN6GjNmg==",
+    "x-cache": "Hit from cloudfront",
+    "cache-control": "public, max-age=31536000, immutable"
+  },
+  "url": "https://deno.land/std@0.92.0/io/bufio.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 961248980
+  }
+}

.deno/deps/https/deno.land/79fa3fa51a04a2aa15ce1e2f8f6d15c1b792c62ecec496f3f23b9f0042f45156

@@ -0,0 +1,15 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+
+export class DenoStdInternalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DenoStdInternalError";
+  }
+}
+
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new DenoStdInternalError(msg);
+  }
+}

.deno/deps/https/deno.land/79fa3fa51a04a2aa15ce1e2f8f6d15c1b792c62ecec496f3f23b9f0042f45156.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "cross-origin-embedder-policy": "same-origin",
+    "x-amz-cf-id": "jPPtAlrdyYFygkOfBSS0hC-v4kBlvCmOHoap2wuVpOcGZ8fbsU4jHQ==",
+    "x-cache": "Hit from cloudfront",
+    "content-length": "405",
+    "last-modified": "Wed, 20 Jan 2021 05:26:03 GMT",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "age": "198167",
+    "server-timing": "fetchSource;dur=16",
+    "accept-ranges": "bytes",
+    "server": "deno/gcp-us-west1",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "x-amz-version-id": "aiYqddAODlxlnFkzLSc7wD_zf0JlIO1I",
+    "cache-control": "public, max-age=31536000, immutable",
+    "date": "Wed, 13 Sep 2023 09:56:10 GMT",
+    "x-frame-options": "DENY",
+    "via": "http/2 edgeproxy-h",
+    "x-amz-replication-status": "COMPLETED",
+    "x-amz-cf-pop": "SEA73-P3",
+    "cross-origin-opener-policy": "same-origin",
+    "content-type": "application/typescript; charset=utf-8",
+    "access-control-allow-origin": "*",
+    "etag": "\"e5ce4111fb107a7ba5b5f7667b7bda6a\"",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "vary": "Accept-Encoding, Origin",
+    "cross-origin-resource-policy": "same-origin",
+    "x-content-type-options": "nosniff"
+  },
+  "url": "https://deno.land/std@0.84.0/_util/assert.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 844987909
+  }
+}

.deno/deps/https/deno.land/7c84f0bf5dd8c48257088f96cefebf3520889c2938e74ef31eb5ca0ed3398b6e

@@ -0,0 +1,132 @@
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+
+import type { FormatInputPathObject } from "./_interface.ts";
+import {
+  CHAR_BACKWARD_SLASH,
+  CHAR_DOT,
+  CHAR_FORWARD_SLASH,
+  CHAR_LOWERCASE_A,
+  CHAR_LOWERCASE_Z,
+  CHAR_UPPERCASE_A,
+  CHAR_UPPERCASE_Z,
+} from "./_constants.ts";
+
+export function assertPath(path: string): void {
+  if (typeof path !== "string") {
+    throw new TypeError(
+      `Path must be a string. Received ${JSON.stringify(path)}`,
+    );
+  }
+}
+
+export function isPosixPathSeparator(code: number): boolean {
+  return code === CHAR_FORWARD_SLASH;
+}
+
+export function isPathSeparator(code: number): boolean {
+  return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;
+}
+
+export function isWindowsDeviceRoot(code: number): boolean {
+  return (
+    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||
+    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)
+  );
+}
+
+// Resolves . and .. elements in a path with directory names
+export function normalizeString(
+  path: string,
+  allowAboveRoot: boolean,
+  separator: string,
+  isPathSeparator: (code: number) => boolean,
+): string {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code: number | undefined;
+  for (let i = 0, len = path.length; i <= len; ++i) {
+    if (i < len) code = path.charCodeAt(i);
+    else if (isPathSeparator(code!)) break;
+    else code = CHAR_FORWARD_SLASH;
+
+    if (isPathSeparator(code!)) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (
+          res.length < 2 ||
+          lastSegmentLength !== 2 ||
+          res.charCodeAt(res.length - 1) !== CHAR_DOT ||
+          res.charCodeAt(res.length - 2) !== CHAR_DOT
+        ) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf(separator);
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) res += `${separator}..`;
+          else res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) res += separator + path.slice(lastSlash + 1, i);
+        else res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === CHAR_DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+export function _format(
+  sep: string,
+  pathObject: FormatInputPathObject,
+): string {
+  const dir: string | undefined = pathObject.dir || pathObject.root;
+  const base: string = pathObject.base ||
+    (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + sep + base;
+}
+
+const WHITESPACE_ENCODINGS: Record<string, string> = {
+  "\u0009": "%09",
+  "\u000A": "%0A",
+  "\u000B": "%0B",
+  "\u000C": "%0C",
+  "\u000D": "%0D",
+  "\u0020": "%20",
+};
+
+export function encodeWhitespace(string: string): string {
+  return string.replaceAll(/[\s]/g, (c) => {
+    return WHITESPACE_ENCODINGS[c] ?? c;
+  });
+}

.deno/deps/https/deno.land/7c84f0bf5dd8c48257088f96cefebf3520889c2938e74ef31eb5ca0ed3398b6e.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "via": "http/2 edgeproxy-h",
+    "server-timing": "fetchSource;dur=8",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "last-modified": "Fri, 02 Apr 2021 05:03:20 GMT",
+    "x-content-type-options": "nosniff",
+    "accept-ranges": "bytes",
+    "cross-origin-opener-policy": "same-origin",
+    "cross-origin-resource-policy": "same-origin",
+    "vary": "Accept-Encoding, Origin",
+    "x-amz-cf-pop": "SEA73-P3",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "content-type": "application/typescript; charset=utf-8",
+    "server": "deno/gcp-us-west1",
+    "access-control-allow-origin": "*",
+    "x-frame-options": "DENY",
+    "cache-control": "public, max-age=31536000, immutable",
+    "x-amz-cf-id": "6fy5WsH5xPeS22L-hfsPv0tw8qb7J5uMhlMggRAjhHe8TPIkLSmZlw==",
+    "x-amz-version-id": "aPCIHJ0Y.kD2tu2QZX2CR3fhvBRkArL1",
+    "etag": "\"f51756a231555d88825200cd1bb125b8\"",
+    "age": "28911890",
+    "date": "Sun, 16 Oct 2022 01:54:07 GMT",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-replication-status": "FAILED",
+    "content-length": "3706",
+    "x-cache": "Hit from cloudfront",
+    "cross-origin-embedder-policy": "same-origin"
+  },
+  "url": "https://deno.land/std@0.92.0/path/_util.ts",
+  "now": {
+    "secs_since_epoch": 1694797136,
+    "nanos_since_epoch": 46025834
+  }
+}

.deno/deps/https/deno.land/7f0ddf903842574b2a331f7a10a8601cc3b6930a32846329b7c607402db08f1b

@@ -0,0 +1,153 @@
+/*!
+ * Ported from: https://github.com/jshttp/mime-types and licensed as:
+ *
+ * (The MIT License)
+ *
+ * Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+ * Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+ * Copyright (c) 2020 the Deno authors
+ * Copyright (c) 2020 the oak authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import { db } from "./db.ts";
+import { extname } from "./deps.ts";
+
+const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+const TEXT_TYPE_REGEXP = /^text\//i;
+
+/** A map of extensions for a given media type */
+export const extensions = new Map<string, string[]>();
+
+/** A map of the media type for a given extension */
+export const types = new Map<string, string>();
+
+/** Internal function to populate the maps based on the Mime DB */
+function populateMaps(
+  extensions: Map<string, string[]>,
+  types: Map<string, string>,
+): void {
+  const preference = ["nginx", "apache", undefined, "iana"];
+
+  for (const type of Object.keys(db)) {
+    const mime = db[type];
+    const exts = mime.extensions;
+
+    if (!exts || !exts.length) {
+      continue;
+    }
+
+    extensions.set(type, exts);
+
+    for (const ext of exts) {
+      const current = types.get(ext);
+      if (current) {
+        const from = preference.indexOf(db[current].source);
+        const to = preference.indexOf(mime.source);
+
+        if (
+          current !== "application/octet-stream" &&
+          (from > to ||
+            (from === to && current.substr(0, 12) === "application/"))
+        ) {
+          continue;
+        }
+      }
+
+      types.set(ext, type);
+    }
+  }
+}
+
+// Populate the maps upon module load
+populateMaps(extensions, types);
+
+/** Given a media type return any default charset string.  Returns `undefined`
+ * if not resolvable.
+ */
+export function charset(type: string): string | undefined {
+  const m = EXTRACT_TYPE_REGEXP.exec(type);
+  if (!m) {
+    return undefined;
+  }
+  const [match] = m;
+  const mime = db[match.toLowerCase()];
+
+  if (mime && mime.charset) {
+    return mime.charset;
+  }
+
+  if (TEXT_TYPE_REGEXP.test(match)) {
+    return "UTF-8";
+  }
+
+  return undefined;
+}
+
+/** Given an extension, lookup the appropriate media type for that extension.
+ * Likely you should be using `contentType()` though instead.
+ */
+export function lookup(path: string): string | undefined {
+  const extension = extname("x." + path)
+    .toLowerCase()
+    .substr(1);
+
+  return types.get(extension);
+}
+
+/** Given an extension or media type, return the full `Content-Type` header
+ * string.  Returns `undefined` if not resolvable.
+ */
+export function contentType(str: string): string | undefined {
+  let mime = str.includes("/") ? str : lookup(str);
+
+  if (!mime) {
+    return undefined;
+  }
+
+  if (!mime.includes("charset")) {
+    const cs = charset(mime);
+    if (cs) {
+      mime += `; charset=${cs.toLowerCase()}`;
+    }
+  }
+
+  return mime;
+}
+
+/** Given a media type, return the most appropriate extension or return
+ * `undefined` if there is none.
+ */
+export function extension(type: string): string | undefined {
+  const match = EXTRACT_TYPE_REGEXP.exec(type);
+
+  if (!match) {
+    return undefined;
+  }
+
+  const exts = extensions.get(match[1].toLowerCase());
+
+  if (!exts || !exts.length) {
+    return undefined;
+  }
+
+  return exts[0];
+}

.deno/deps/https/deno.land/7f0ddf903842574b2a331f7a10a8601cc3b6930a32846329b7c607402db08f1b.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "etag": "\"e7fbec37577c75cd38625a8dfb6bb80c\"",
+    "cross-origin-resource-policy": "same-origin",
+    "x-frame-options": "DENY",
+    "cross-origin-embedder-policy": "same-origin",
+    "x-amz-cf-pop": "SEA73-P3",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "access-control-allow-origin": "*",
+    "last-modified": "Thu, 21 Jan 2021 22:00:01 GMT",
+    "age": "29184345",
+    "via": "http/2 edgeproxy",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "cache-control": "public, max-age=31536000, immutable",
+    "server": "deno/gcp-us-west1",
+    "server-timing": "fetchSource;dur=8",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "x-amz-cf-id": "zO17KixM5csy_GHnaXNwG1T3Sg0ovZI9E9w5p0q4Ft9hNMBIrN63TQ==",
+    "x-amz-version-id": "K4jtseUmiRsDqkrvlgxIOZWxs5t34jM4",
+    "x-cache": "Hit from cloudfront",
+    "content-type": "application/typescript; charset=utf-8",
+    "date": "Wed, 12 Oct 2022 22:13:11 GMT",
+    "vary": "Accept-Encoding, Origin",
+    "cross-origin-opener-policy": "same-origin",
+    "accept-ranges": "bytes",
+    "x-amz-replication-status": "FAILED",
+    "content-length": "4317",
+    "x-content-type-options": "nosniff"
+  },
+  "url": "https://deno.land/x/media_types@v2.7.1/mod.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 500065859
+  }
+}

.deno/deps/https/deno.land/7fafc2af7ec45b2c2974a99211673659bce419c1811d4c7d030f7d8ffd7bcc19

@@ -0,0 +1,39 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { SEP } from "./separator.ts";
+
+/** Determines the common path from a set of paths, using an optional separator,
+ * which defaults to the OS default separator.
+ *
+ *       import { common } from "https://deno.land/std/path/mod.ts";
+ *       const p = common([
+ *         "./deno/std/path/mod.ts",
+ *         "./deno/std/fs/mod.ts",
+ *       ]);
+ *       console.log(p); // "./deno/std/"
+ *
+ */
+export function common(paths: string[], sep = SEP): string {
+  const [first = "", ...remaining] = paths;
+  if (first === "" || remaining.length === 0) {
+    return first.substring(0, first.lastIndexOf(sep) + 1);
+  }
+  const parts = first.split(sep);
+
+  let endOfPrefix = parts.length;
+  for (const path of remaining) {
+    const compare = path.split(sep);
+    for (let i = 0; i < endOfPrefix; i++) {
+      if (compare[i] !== parts[i]) {
+        endOfPrefix = i;
+      }
+    }
+
+    if (endOfPrefix === 0) {
+      return "";
+    }
+  }
+  const prefix = parts.slice(0, endOfPrefix).join(sep);
+  return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`;
+}

.deno/deps/https/deno.land/7fafc2af7ec45b2c2974a99211673659bce419c1811d4c7d030f7d8ffd7bcc19.metadata.json

@@ -0,0 +1,35 @@
+{
+  "headers": {
+    "x-amz-cf-pop": "SEA73-P3",
+    "x-amz-replication-status": "FAILED",
+    "x-amz-cf-id": "bn9JRwODH5e0QWiywRFWGODbHhQhcwO5Qba5EJiDMqXPd_UHfDsG6g==",
+    "cross-origin-embedder-policy": "same-origin",
+    "x-amz-version-id": "2DH2gNqw0Do7JdmTRJ1SeZABkGPL3ntR",
+    "x-content-type-options": "nosniff",
+    "x-cache": "Hit from cloudfront",
+    "server": "deno/gcp-us-west1",
+    "etag": "\"563fa4ed09afad6fac675949f387b257\"",
+    "age": "28911889",
+    "date": "Sun, 16 Oct 2022 01:54:07 GMT",
+    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "content-type": "application/typescript; charset=utf-8",
+    "x-frame-options": "DENY",
+    "cross-origin-resource-policy": "same-origin",
+    "last-modified": "Fri, 02 Apr 2021 05:03:20 GMT",
+    "referrer-policy": "strict-origin-when-cross-origin",
+    "via": "http/2 edgeproxy-h",
+    "accept-ranges": "bytes",
+    "access-control-allow-origin": "*",
+    "cache-control": "public, max-age=31536000, immutable",
+    "content-length": "1166",
+    "cross-origin-opener-policy": "same-origin",
+    "server-timing": "fetchSource;dur=14",
+    "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
+    "vary": "Accept-Encoding, Origin"
+  },
+  "url": "https://deno.land/std@0.92.0/path/common.ts",
+  "now": {
+    "secs_since_epoch": 1694797135,
+    "nanos_since_epoch": 856729975
+  }
+}