Upload Kmake

deps/uv/.gitattributes

@@ -0,0 +1 @@
+test/fixtures/lorem_ipsum.txt text eol=lf

deps/uv/.gitignore

@@ -0,0 +1,80 @@
+*.swp
+*.[oa]
+*.l[oa]
+*.opensdf
+*.orig
+*.pyc
+*.sdf
+*.suo
+.vs/
+.vscode/
+*.VC.db
+*.VC.opendb
+core
+.cache
+vgcore.*
+.buildstamp
+.dirstamp
+.deps/
+/.libs/
+/aclocal.m4
+/ar-lib
+/autom4te.cache/
+/compile
+/config.guess
+/config.log
+/config.status
+/config.sub
+/configure
+/depcomp
+/install-sh
+/libtool
+/libuv.a
+/libuv.dylib
+/libuv.pc
+/libuv.so
+/ltmain.sh
+/missing
+/test-driver
+Makefile
+Makefile.in
+
+/build/
+
+/test/.libs/
+/test/run-tests
+/test/run-tests.exe
+/test/run-tests.dSYM
+/test/run-benchmarks
+/test/run-benchmarks.exe
+/test/run-benchmarks.dSYM
+test_file_*
+
+*.sln
+*.sln.cache
+*.ncb
+*.vcproj
+*.vcproj*.user
+*.vcxproj
+*.vcxproj.filters
+*.vcxproj.user
+_UpgradeReport_Files/
+UpgradeLog*.XML
+Debug
+Release
+ipch
+
+# sphinx generated files
+/docs/build/
+
+# Clion / IntelliJ project files
+/.idea/
+cmake-build-debug/
+
+*.xcodeproj
+*.xcworkspace
+
+# make dist output
+libuv-*.tar.*
+/dist.libuv.org/
+/libuv-release-tool/

deps/uv/.mailmap

@@ -0,0 +1,71 @@
+A. Hauptmann <andreashauptmann@t-online.de>
+AJ Heller <aj@drfloob.com> <hork@google.com>
+Aaron Bieber <qbit@deftly.net> <deftly@gmail.com>
+Alan Gutierrez <alan@prettyrobots.com> <alan@blogometer.com>
+Andrius Bentkus <andrius.bentkus@gmail.com> <toxedvirus@gmail.com>
+Andy Fiddaman <andy@omniosce.org> <omnios@citrus-it.co.uk>
+Andy Pan <panjf2000@gmail.com> <i@andypan.me>
+Bert Belder <bertbelder@gmail.com> <i@bertbelder.com>
+Bert Belder <bertbelder@gmail.com> <info@2bs.nl>
+Bert Belder <bertbelder@gmail.com> <user@ChrUbuntu.(none)>
+Brandon Philips <brandon.philips@rackspace.com> <brandon@ifup.org>
+Brian White <mscdex@mscdex.net>
+Brian White <mscdex@mscdex.net> <mscdex@gmail.com>
+Caleb James DeLisle <cjd@hyperboria.ca> <cjd@cjdns.fr>
+Christoph Iserlohn <christoph.iserlohn@innoq.com>
+Darshan Sen <raisinten@gmail.com>
+Darshan Sen <raisinten@gmail.com> <darshan.sen@postman.com>
+David Carlier <devnexen@gmail.com>
+Devchandra Meetei Leishangthem <dlmeetei@gmail.com>
+Fedor Indutny <fedor.indutny@gmail.com> <fedor@indutny.com>
+Frank Denis <github@pureftpd.org>
+Hüseyin Açacak <110401522+huseyinacacak-janea@users.noreply.github.com> <huseyin@janeasystems.com>
+Imran Iqbal <imrani@ca.ibm.com> <imran@imraniqbal.org>
+Isaac Z. Schlueter <i@izs.me>
+Jason Williams <necmon@yahoo.com>
+Jesse Gorzinski <jgorzinski@gmail.com>
+Jesse Gorzinski <jgorzinski@gmail.com> <jgorzins@us.ibm.com>
+Juan José Arboleda <soyjuanarbol@gmail.com>
+Justin Venus <justin.venus@gmail.com> <justin.venus@orbitz.com>
+Keno Fischer <kenof@stanford.edu> <kfischer+github@college.harvard.edu>
+Keno Fischer <kenof@stanford.edu> <kfischer@college.harvard.edu>
+Leith Bade <leith@leithalweapon.geek.nz> <leith@mapbox.com>
+Leonard Hecker <leonard.hecker91@gmail.com> <leonard@hecker.io>
+Lewis Russell <me@lewisr.dev> <lewis6991@gmail.com>
+Maciej Małecki <maciej.malecki@notimplemented.org> <me@mmalecki.com>
+Marc Schlaich <marc.schlaich@googlemail.com> <marc.schlaich@gmail.com>
+Michael <michael_dawson@ca.ibm.com>
+Michael Neumann <mneumann@think.localnet> <mneumann@ntecs.de>
+Michael Penick <michael.penick@datastax.com> <mpenick@users.noreply.github.com>
+Nicholas Vavilov <vvnicholas@gmail.com>
+Nick Logan <ugexe@cpan.org> <nlogan@gmail.com>
+Olivier Valentin <ovalenti@redhat.com> <valentio@free.fr>
+Rasmus Christian Pedersen <zerhacken@yahoo.com>
+Rasmus Christian Pedersen <zerhacken@yahoo.com> <ruysch@outlook.com>
+Richard Lau <rlau@redhat.com> <riclau@uk.ibm.com>
+Robert Mustacchi <rm@joyent.com> <rm@fingolfin.org>
+Ryan Dahl <ryan@joyent.com> <ry@tinyclouds.org>
+Ryan Emery <seebees@gmail.com>
+Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
+Sam Roberts <vieuxtech@gmail.com> <sam@strongloop.com>
+San-Tai Hsu <vanilla@fatpipi.com>
+Santiago Gimeno <santiago.gimeno@quantion.es> <santiago.gimeno@gmail.com>
+Saúl Ibarra Corretgé <s@saghul.net>
+Saúl Ibarra Corretgé <s@saghul.net> <saghul@gmail.com>
+Saúl Ibarra Corretgé <saghul@gmail.com> <s@saghul.net>
+Shigeki Ohtsu <ohtsu@iij.ad.jp> <ohtsu@ohtsu.org>
+Shuowang (Wayne) Zhang <shuowang.zhang@ibm.com>
+TK-one <tk5641@naver.com>
+Timothy J. Fontaine <tjfontaine@gmail.com>
+Yasuhiro Matsumoto <mattn.jp@gmail.com>
+Yazhong Liu <yorkiefixer@gmail.com>
+Yuki Okumura <mjt@cltn.org>
+cjihrig <cjihrig@gmail.com>
+gengjiawen <technicalcute@gmail.com>
+jBarz <jBarz@users.noreply.github.com> <jbarboza@ca.ibm.com>
+jBarz <jBarz@users.noreply.github.com> <jbarz@users.noreply.github.com>
+ptlomholt <pt@lomholt.com>
+theanarkh <2923878201@qq.com> <theratliter@gmail.com>
+tjarlama <59913901+tjarlama@users.noreply.github.com> <tjarlama@gmail.com>
+ywave620 <rogertyang@tencent.com> <60539365+ywave620@users.noreply.github.com>
+zlargon <zlargon1988@gmail.com>

deps/uv/.readthedocs.yaml

@@ -0,0 +1,15 @@
+version: 2
+
+sphinx:
+  builder: html
+  configuration: docs/src/conf.py
+  fail_on_warning: false
+
+build:
+  os: "ubuntu-22.04"
+  tools:
+    python: "3.9"
+
+python:
+  install:
+    - requirements: docs/requirements.txt

deps/uv/AUTHORS

@@ -0,0 +1,606 @@
+# Authors ordered by first contribution.
+Ryan Dahl <ryan@joyent.com>
+Bert Belder <bertbelder@gmail.com>
+Josh Roesslein <jroesslein@gmail.com>
+Alan Gutierrez <alan@prettyrobots.com>
+Joshua Peek <josh@joshpeek.com>
+Igor Zinkovsky <igorzi@microsoft.com>
+San-Tai Hsu <vanilla@fatpipi.com>
+Ben Noordhuis <info@bnoordhuis.nl>
+Henry Rawas <henryr@schakra.com>
+Robert Mustacchi <rm@joyent.com>
+Matt Stevens <matt@alloysoft.com>
+Paul Querna <pquerna@apache.org>
+Shigeki Ohtsu <ohtsu@iij.ad.jp>
+Tom Hughes <tom.hughes@palm.com>
+Peter Bright <drpizza@quiscalusmexicanus.org>
+Jeroen Janssen <jeroen.janssen@gmail.com>
+Andrea Lattuada <ndr.lattuada@gmail.com>
+Augusto Henrique Hentz <ahhentz@gmail.com>
+Clifford Heath <clifford.heath@gmail.com>
+Jorge Chamorro Bieling <jorge@jorgechamorro.com>
+Luis Lavena <luislavena@gmail.com>
+Matthew Sporleder <msporleder@gmail.com>
+Erick Tryzelaar <erick.tryzelaar@gmail.com>
+Isaac Z. Schlueter <i@izs.me>
+Pieter Noordhuis <pcnoordhuis@gmail.com>
+Marek Jelen <marek@jelen.biz>
+Fedor Indutny <fedor.indutny@gmail.com>
+Saúl Ibarra Corretgé <saghul@gmail.com>
+Felix Geisendörfer <felix@debuggable.com>
+Yuki Okumura <mjt@cltn.org>
+Roman Shtylman <shtylman@gmail.com>
+Frank Denis <github@pureftpd.org>
+Carter Allen <CarterA@opt-6.com>
+Tj Holowaychuk <tj@vision-media.ca>
+Shimon Doodkin <helpmepro1@gmail.com>
+Ryan Emery <seebees@gmail.com>
+Bruce Mitchener <bruce.mitchener@gmail.com>
+Maciej Małecki <maciej.malecki@notimplemented.org>
+Yasuhiro Matsumoto <mattn.jp@gmail.com>
+Daisuke Murase <typester@cpan.org>
+Paddy Byers <paddy.byers@gmail.com>
+Dan VerWeire <dverweire@gmail.com>
+Brandon Benvie <brandon@bbenvie.com>
+Brandon Philips <brandon.philips@rackspace.com>
+Nathan Rajlich <nathan@tootallnate.net>
+Charlie McConnell <charlie@charlieistheman.com>
+Vladimir Dronnikov <dronnikov@gmail.com>
+Aaron Bieber <qbit@deftly.net>
+Bulat Shakirzyanov <mallluhuct@gmail.com>
+Brian White <mscdex@mscdex.net>
+Erik Dubbelboer <erik@dubbelboer.com>
+Keno Fischer <kenof@stanford.edu>
+Ira Cooper <Ira.Cooper@mathworks.com>
+Andrius Bentkus <andrius.bentkus@gmail.com>
+Iñaki Baz Castillo <ibc@aliax.net>
+Mark Cavage <mark.cavage@joyent.com>
+George Yohng <georgegh@oss3d.com>
+Xidorn Quan <quanxunzhen@gmail.com>
+Roman Neuhauser <rneuhauser@suse.cz>
+Shuhei Tanuma <shuhei.tanuma@gmail.com>
+Bryan Cantrill <bcantrill@acm.org>
+Trond Norbye <trond.norbye@gmail.com>
+Tim Holy <holy@wustl.edu>
+Prancesco Pertugio <meh@schizofreni.co>
+Leonard Hecker <leonard.hecker91@gmail.com>
+Andrew Paprocki <andrew@ishiboo.com>
+Luigi Grilli <luigi.grilli@gmail.com>
+Shannen Saez <shannenlaptop@gmail.com>
+Artur Adib <arturadib@gmail.com>
+Hiroaki Nakamura <hnakamur@gmail.com>
+Ting-Yu Lin <ph.minamo@cytisan.com>
+Stephen Gallagher <sgallagh@redhat.com>
+Shane Holloway <shane.holloway@ieee.org>
+Andrew Shaffer <darawk@gmail.com>
+Vlad Tudose <vlad.tudose@intel.com>
+Ben Leslie <benno@benno.id.au>
+Tim Bradshaw <tfb@cley.com>
+Timothy J. Fontaine <tjfontaine@gmail.com>
+Marc Schlaich <marc.schlaich@googlemail.com>
+Brian Mazza <louseman@gmail.com>
+Elliot Saba <staticfloat@gmail.com>
+Ben Kelly <ben@wanderview.com>
+Nils Maier <maierman@web.de>
+Nicholas Vavilov <vvnicholas@gmail.com>
+Miroslav Bajtoš <miro.bajtos@gmail.com>
+Sean Silva <chisophugis@gmail.com>
+Wynn Wilkes <wynnw@movenetworks.com>
+Andrei Sedoi <bsnote@gmail.com>
+Alex Crichton <alex@alexcrichton.com>
+Brent Cook <brent@boundary.com>
+Brian Kaisner <bkize1@gmail.com>
+Luca Bruno <lucab@debian.org>
+Reini Urban <rurban@cpanel.net>
+Maks Naumov <maksqwe1@ukr.net>
+Sean Farrell <sean.farrell@rioki.org>
+Chris Bank <cbank@adobe.com>
+Geert Jansen <geertj@gmail.com>
+Christoph Iserlohn <christoph.iserlohn@innoq.com>
+Steven Kabbes <stevenkabbes@gmail.com>
+Alex Gaynor <alex.gaynor@gmail.com>
+huxingyi <huxingyi@msn.com>
+Tenor Biel <tenorbiel@gmail.com>
+Andrej Manduch <AManduch@gmail.com>
+Joshua Neuheisel <joshua@neuheisel.us>
+Alexis Campailla <alexis@janeasystems.com>
+Yazhong Liu <yorkiefixer@gmail.com>
+Sam Roberts <vieuxtech@gmail.com>
+River Tarnell <river@loreley.flyingparchment.org.uk>
+Nathan Sweet <nathanjsweet@gmail.com>
+Trevor Norris <trev.norris@gmail.com>
+Oguz Bastemur <obastemur@gmail.com>
+Dylan Cali <calid1984@gmail.com>
+Austin Foxley <austinf@cetoncorp.com>
+Benjamin Saunders <ben.e.saunders@gmail.com>
+Geoffry Song <goffrie@gmail.com>
+William Light <wrl@illest.net>
+Oleg Efimov <o.efimov@corp.badoo.com>
+Lars Gierth <larsg@systemli.org>
+Rasmus Christian Pedersen <zerhacken@yahoo.com>
+Justin Venus <justin.venus@gmail.com>
+Kristian Evensen <kristian.evensen@gmail.com>
+Linus Mårtensson <linus.martensson@sonymobile.com>
+Navaneeth Kedaram Nambiathan <navaneethkn@gmail.com>
+StarWing <weasley.wx@gmail.com>
+thierry-FreeBSD <thierry@FreeBSD.org>
+Isaiah Norton <isaiah.norton@gmail.com>
+Raul Martins <raulms.martins@gmail.com>
+David Capello <davidcapello@gmail.com>
+Paul Tan <pyokagan@gmail.com>
+Javier Hernández <jhernandez@emergya.com>
+Tonis Tiigi <tonistiigi@gmail.com>
+Norio Kobota <nori.0428@gmail.com>
+李港平 <chopdown@gmail.com>
+Chernyshev Viacheslav <astellar@ro.ru>
+Stephen von Takach <steve@advancedcontrol.com.au>
+JD Ballard <jd@pixelandline.com>
+Luka Perkov <luka.perkov@sartura.hr>
+Ryan Cole <ryan@rycole.com>
+HungMingWu <u9089000@gmail.com>
+Jay Satiro <raysatiro@yahoo.com>
+Leith Bade <leith@leithalweapon.geek.nz>
+Peter Atashian <retep998@gmail.com>
+Tim Cooper <tim.cooper@layeh.com>
+Caleb James DeLisle <cjd@hyperboria.ca>
+Jameson Nash <vtjnash@gmail.com>
+Graham Lee <ghmlee@ghmlee.com>
+Andrew Low <Andrew_Low@ca.ibm.com>
+Pavel Platto <hinidu@gmail.com>
+Tony Kelman <tony@kelman.net>
+John Firebaugh <john.firebaugh@gmail.com>
+lilohuang <lilohuang@hotmail.com>
+Paul Goldsmith <paul.goldsmith@aplink.net>
+Julien Gilli <julien.gilli@joyent.com>
+Michael Hudson-Doyle <michael.hudson@linaro.org>
+Recep ASLANTAS <m@recp.me>
+Rob Adams <readams@readams.net>
+Zachary Newman <znewman01@gmail.com>
+Robin Hahling <robin.hahling@gw-computing.net>
+Jeff Widman <jeff@jeffwidman.com>
+cjihrig <cjihrig@gmail.com>
+Tomasz Kołodziejski <tkolodziejski@mozilla.com>
+Unknown W. Brackets <checkins@unknownbrackets.org>
+Emmanuel Odeke <odeke@ualberta.ca>
+Mikhail Mukovnikov <yndi@me.com>
+Thorsten Lorenz <thlorenz@gmx.de>
+Yuri D'Elia <yuri.delia@eurac.edu>
+Manos Nikolaidis <manos@shadowrobot.com>
+Elijah Andrews <elijah@busbud.com>
+Michael Ira Krufky <m.krufky@samsung.com>
+Helge Deller <deller@gmx.de>
+Joey Geralnik <jgeralnik@gmail.com>
+Tim Caswell <tim@creationix.com>
+Logan Rosen <loganrosen@gmail.com>
+Kenneth Perry <thothonegan@gmail.com>
+John Marino <marino@FreeBSD.org>
+Alexey Melnichuk <mimir@newmail.ru>
+Johan Bergström <bugs@bergstroem.nu>
+Alex Mo <almosnow@gmail.com>
+Luis Martinez de Bartolome <lasote@gmail.com>
+Michael Penick <michael.penick@datastax.com>
+Michael <michael_dawson@ca.ibm.com>
+Massimiliano Torromeo <massimiliano.torromeo@gmail.com>
+TomCrypto <thomas.beneteau@yahoo.fr>
+Brett Vickers <brett@beevik.com>
+Ole André Vadla Ravnås <oleavr@gmail.com>
+Kazuho Oku <kazuhooku@gmail.com>
+Ryan Phillips <ryan.phillips@rackspace.com>
+Brian Green <briangreenery@gmail.com>
+Devchandra Meetei Leishangthem <dlmeetei@gmail.com>
+Corey Farrell <git@cfware.com>
+Per Nilsson <pni@qlik.com>
+Alan Rogers <alanjrogers@me.com>
+Daryl Haresign <github@daryl.haresign.com>
+Rui Abreu Ferreira <raf-ep@gmx.com>
+João Reis <reis@janeasystems.com>
+farblue68 <farblue68@gmail.com>
+Jason Williams <necmon@yahoo.com>
+Igor Soarez <igorsoarez@gmail.com>
+Miodrag Milanovic <mmicko@gmail.com>
+Cheng Zhao <zcbenz@gmail.com>
+Michael Neumann <mneumann@think.localnet>
+Stefano Cristiano <stefanocristiano82@gmail.com>
+heshamsafi <hesham.safi.eldeen@gmail.com>
+A. Hauptmann <andreashauptmann@t-online.de>
+John McNamee <jpm@microwiz.com>
+Yosuke Furukawa <yosuke.furukawa@gmail.com>
+Santiago Gimeno <santiago.gimeno@quantion.es>
+guworks <ground.up.works@gmail.com>
+RossBencina <rossb@audiomulch.com>
+Roger A. Light <roger@atchoo.org>
+chenttuuvv <chenttuuvv@yahoo.com>
+Richard Lau <rlau@redhat.com>
+ronkorving <rkorving@wizcorp.jp>
+Corbin Simpson <MostAwesomeDude@gmail.com>
+Zachary Hamm <zsh@imipolexg.org>
+Karl Skomski <karl@skomski.com>
+Jeremy Whitlock <jwhitlock@apache.org>
+Willem Thiart <himself@willemthiart.com>
+Ben Trask <bentrask@comcast.net>
+Jianghua Yang <jianghua.yjh@alibaba-inc.com>
+Colin Snover <github.com@zetafleet.com>
+Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
+Eli Skeggs <skeggse@gmail.com>
+nmushell <nmushell@bloomberg.net>
+Gireesh Punathil <gpunathi@in.ibm.com>
+Ryan Johnston <ryan@mediapixel.co.nz>
+Adam Stylinski <stylinae@mail.uc.edu>
+Nathan Corvino <nathan@corvino.com>
+Wink Saville <wink@saville.com>
+Angel Leon <gubatron@gmail.com>
+Louis DeJardin <lodejard@microsoft.com>
+Imran Iqbal <imrani@ca.ibm.com>
+Petka Antonov <petka_antonov@hotmail.com>
+Ian Kronquist <iankronquist@teleport.com>
+kkdaemon <kkdaemon@gmail.com>
+Yuval Brik <yuval@brik.org.il>
+Joran Dirk Greef <joran@ronomon.com>
+Andrey Mazo <andrey.mazo@fidelissecurity.com>
+sztomi <hello.sztomi@gmail.com>
+Martin Bark <martin@barkynet.com>
+Dave <dave@jut.io>
+Alexis Murzeau <amubtdx@gmail.com>
+Didiet <lynxluna@gmail.com>
+Nan Xiang <514580344@qq.com>
+Samuel Lorétan <sloretan@riotgames.com>
+Nándor István Krácser <bonifaido@gmail.com>
+Katsutoshi Horie <mps299792458@gmail.com>
+Lukasz Jagiello <lukasz@wikia-inc.com>
+Robert Chiras <robert.chiras@intel.com>
+Kári Tristan Helgason <kthelgason@gmail.com>
+Krishnaraj Bhat <krrishnarraj@gmail.com>
+Enno Boland <g@s01.de>
+Michael Fero <michael.fero@datastax.com>
+Robert Jefe Lindstaedt <robert.lindstaedt@gmail.com>
+Myles Borins <myles.borins@gmail.com>
+Tony Theodore <tonyt@logyst.com>
+Jason Ginchereau <jasongin@microsoft.com>
+Nicolas Cavallari <nicolas.cavallari@green-communications.fr>
+Pierre-Marie de Rodat <pmderodat@kawie.fr>
+Brian Maher <brian@brimworks.com>
+neevek <i@neevek.net>
+John Barboza <jbarboza@ca.ibm.com>
+liuxiaobo <icexile@qq.com>
+Michele Caini <michele.caini@gmail.com>
+Bartosz Sosnowski <bartosz@janeasystems.com>
+Matej Knopp <matej.knopp@gmail.com>
+sunjin.lee <kod21236@gmail.com>
+Matt Clarkson <mattyclarkson@gmail.com>
+Jeffrey Clark <dude@zaplabs.com>
+Bart Robinson <bartarr@gmail.com>
+Vit Gottwald <vit.gottwald@gmail.com>
+Vladimír Čunát <vladimir.cunat@nic.cz>
+Alex Hultman <alexhultman@gmail.com>
+Brad King <brad.king@kitware.com>
+Philippe Laferriere <laferriere.phil@gmail.com>
+Will Speak <lithiumflame@gmail.com>
+Hitesh Kanwathirtha <digitalinfinity@gmail.com>
+Eric Sciple <ersciple@microsoft.com>
+jBarz <jBarz@users.noreply.github.com>
+muflub <admin@lodle.net>
+Daniel Bevenius <daniel.bevenius@gmail.com>
+Howard Hellyer <hhellyer@uk.ibm.com>
+Chris Araman <chris.araman@fuze.com>
+Vladimir Matveev <vladima@microsoft.com>
+Jason Madden <jamadden@gmail.com>
+Jamie Davis <davisjam@vt.edu>
+Daniel Kahn Gillmor <dkg@fifthhorseman.net>
+Keane <erich.keane@intel.com>
+James McCoy <jamessan@jamessan.com>
+Bernardo Ramos <berna.gensis@gmail.com>
+Juan Cruz Viotti <jviotti@openmailbox.org>
+Gemini Wen <geminiwen@aliyun.com>
+Sebastian Wiedenroth <wiedi@frubar.net>
+Sai Ke WANG <swang304@bloomberg.net>
+Barnabas Gema <gema.barnabas@gmail.com>
+Romain Caire <romain@blade-group.com>
+Robert Ayrapetyan <robert.ayrapetyan@gmail.com>
+Refael Ackermann <refack@gmail.com>
+André Klitzing <aklitzing@gmail.com>
+Matthew Taylor <mstaveleytaylor@gmail.com>
+CurlyMoo <curlymoo1@gmail.com>
+XadillaX <admin@xcoder.in>
+Anticrisis <anticrisisg@gmail.com>
+Jacob Segal <jacob.e.segal@gmail.com>
+Maciej Szeptuch (Neverous) <neverous@neverous.info>
+Joel Winarske <joel.winarske@inrix.com>
+Gergely Nagy <ngg@tresorit.com>
+Kamil Rytarowski <n54@gmx.com>
+tux.uudiin <77389867@qq.com>
+Nick Logan <ugexe@cpan.org>
+darobs <darobs@microsoft.com>
+Zheng, Lei <realthunder.dev@gmail.com>
+Carlo Marcelo Arenas Belón <carenas@gmail.com>
+Scott Parker <scott.parker087@gmail.com>
+Wade Brainerd <Wade.Brainerd@activision.com>
+rayrase <rmartinez2175@eagle.fgcu.edu>
+Pekka Nikander <pekka.nikander@iki.fi>
+Ed Schouten <ed@nuxi.nl>
+Xu Meng <mengxumx@cn.ibm.com>
+Matt Harrison <hi@matt-harrison.com>
+Anna Henningsen <anna@addaleax.net>
+Jérémy Lal <kapouer@melix.org>
+Ben Wijen <ben@wijen.net>
+elephantp <elephantp@elephantp.blog>
+Felix Yan <felixonmars@archlinux.org>
+Mason X <me@masonx.ca>
+Jesse Gorzinski <jgorzinski@gmail.com>
+Ryuichi KAWAMATA <ryuichi.kawamata@dena.jp>
+Joyee Cheung <joyeec9h3@gmail.com>
+Michael Kilburn <crusader.mike@gmail.com>
+Ruslan Bekenev <furyinbox@gmail.com>
+Bob Burger <rgburger@beckman.com>
+Thomas Versteeg <thomasversteeg@gmx.com>
+zzzjim <zzzjim@users.noreply.github.com>
+Alex Arslan <ararslan@comcast.net>
+Kyle Farnung <kfarnung@microsoft.com>
+ssrlive <30760636+ssrlive@users.noreply.github.com>
+Tobias Nießen <tniessen@tnie.de>
+Björn Linse <bjorn.linse@gmail.com>
+zyxwvu Shi <i@shiyc.cn>
+Peter Johnson <johnson.peter@gmail.com>
+Paolo Greppi <paolo.greppi@libpf.com>
+Shelley Vohr <shelley.vohr@gmail.com>
+Ujjwal Sharma <usharma1998@gmail.com>
+Michał Kozakiewicz <michalkozakiewicz3@gmail.com>
+Emil Bay <github@tixz.dk>
+Jeremiah Senkpiel <fishrock123@rocketmail.com>
+Andy Zhang <zhangyong232@gmail.com>
+dmabupt <dmabupt@gmail.com>
+Ryan Liptak <squeek502@hotmail.com>
+Ali Ijaz Sheikh <ofrobots@google.com>
+hitesh <sainihitesh.scientist@gmail.com>
+Svante Signell <svante.signell@gmail.com>
+Samuel Thibault <sthibault@debian.org>
+Jeremy Studer <studerj1.mail@gmail.com>
+damon-kwok <563066990@qq.com>
+Damon Kwok <MedusaIDE@outlook.com>
+Ashe Connor <ashe@kivikakk.ee>
+Rick <lcw0622@163.com>
+Ivan Krylov <krylov.r00t@gmail.com>
+Michael Meier <michael.meier@leica-geosystems.com>
+ptlomholt <pt@lomholt.com>
+Victor Costan <pwnall@chromium.org>
+sid <sidyhe@hotmail.com>
+Kevin Adler <kadler@us.ibm.com>
+Stephen Belanger <admin@stephenbelanger.com>
+yeyuanfeng <yeyuanfeng@bytedance.com>
+erw7 <erw7.github@gmail.com>
+Thomas Karl Pietrowski <thopiekar@gmail.com>
+evgley <evgley@gmail.com>
+Andreas Rohner <andreas.rohner@gmx.net>
+Rich Trott <rtrott@gmail.com>
+Milad Farazmand <miladfar@ca.ibm.com>
+zlargon <zlargon1988@gmail.com>
+Yury Selivanov <yury@magic.io>
+Oscar Waddell <owaddell@beckman.com>
+FX Coudert <fxcoudert@gmail.com>
+George Zhao <zhaozg@gmail.com>
+Kyle Edwards <kyle.edwards@kitware.com>
+ken-cunningham-webuse <ken.cunningham.webuse@gmail.com>
+Kelvin Jin <kelvinjin@google.com>
+Leorize <leorize+oss@disroot.org>
+Vlad A <vladmore@gmail.com>
+Niels Lohmann <mail@nlohmann.me>
+Jenil Christo <jenilchristo5@gmail.com>
+Evgeny Ermakov <evgeny.v.ermakov@gmail.com>
+gengjiawen <technicalcute@gmail.com>
+Leo Chung <gewalalb@gmail.com>
+Javier Blazquez <jblazquez@riotgames.com>
+Mustafa M <mus-m@outlook.com>
+Zach Bjornson <zbbjornson@gmail.com>
+Nan Xiao <nan@chinadtrace.org>
+Ben Davies <kaiepi@outlook.com>
+Nhan Khong <knhana7@gmail.com>
+Crunkle <justcrunkle@hotmail.co.uk>
+Tomas Krizek <tomas.krizek@nic.cz>
+Konstantin Podsvirov <konstantin@podsvirov.pro>
+seny <arseny.vakhrushev@gmail.com>
+Vladimir Karnushin <v.karnushin@mail.ru>
+MaYuming <maym@appexnetworks.com>
+Eneas U de Queiroz <cotequeiroz@gmail.com>
+Daniel Hahler <git@thequod.de>
+Yang Yu <yang.yu@disigma.org>
+David Carlier <devnexen@gmail.com>
+Calvin Hill <calvin@hakobaito.co.uk>
+Isabella Muerte <63051+slurps-mad-rips@users.noreply.github.com>
+Ouyang Yadong <oyydoibh@gmail.com>
+ZYSzys <zyszys98@gmail.com>
+Carl Lei <xecycle@gmail.com>
+Stefan Bender <stefan.bender@ntnu.no>
+nia <nia@NetBSD.org>
+virtualyw <virtualyw@gmail.com>
+Witold Kręcicki <wpk@isc.org>
+Dominique Dumont <dod@debian.org>
+Manuel BACHMANN <tarnyko@tarnyko.net>
+Marek Vavrusa <marek@vavrusa.com>
+TK-one <tk5641@naver.com>
+Irek Fakhrutdinov <ifakhrutdinov@rocketsoftware.com>
+Lin Zhang <linroid@gmail.com>
+毛毛 <srayuws@users.noreply.github.com>
+Sk Sajidul Kadir <sheikh.sajid522@gmail.com>
+twosee <twose@qq.com>
+Rikard Falkeborn <rikard.falkeborn@gmail.com>
+Yash Ladha <yashladhapankajladha123@gmail.com>
+James Ross <git@james-ross.co.uk>
+Colin Finck <colin@reactos.org>
+Shohei YOSHIDA <syohex@gmail.com>
+Philip Chimento <philip.chimento@gmail.com>
+Michal Artazov <michal@artazov.cz>
+Jeroen Roovers <jer@gentoo.org>
+MasterDuke17 <MasterDuke17@users.noreply.github.com>
+Alexander Tokmakov <avtokmakov@yandex-team.ru>
+Arenoros <arenoros@gmail.com>
+lander0s <dh.landeros08@gmail.com>
+Turbinya <wownucleos@gmail.com>
+OleksandrKvl <oleksandrdvl@gmail.com>
+Carter Li <carter.li@eoitek.com>
+Juan Sebastian velez Posada <jvelezpo@users.noreply.github.com>
+escherstair <ernestviga@gmail.com>
+Evan Lucas <evanlucas@me.com>
+tjarlama <59913901+tjarlama@users.noreply.github.com>
+司徒玟琅 <sanjusss@qq.com>
+YuMeiJie <yumeijie@huawei.com>
+Aleksej Lebedev <root@zta.lk>
+Nikolay Mitev <github@hmel.org>
+Ulrik Strid <ulrik.strid@outlook.com>
+Elad Lahav <elahav@qnx.com>
+Elad Nachmias <eladn@pazam.net>
+Darshan Sen <raisinten@gmail.com>
+Simon Kadisch <simon.kadisch@k13-engineering.at>
+Momtchil Momtchev <momtchil@momtchev.com>
+Ethel Weston <66453757+ethelweston@users.noreply.github.com>
+Drew DeVault <sir@cmpwn.com>
+Mark Klein <klein@cscs.ch>
+schamberg97 <50446906+schamberg97@users.noreply.github.com>
+Bob Weinand <bobwei9@hotmail.com>
+Issam E. Maghni <issam.e.maghni@mailbox.org>
+Juan Pablo Canepa <jpcanepa@gmail.com>
+Shuowang (Wayne) Zhang <shuowang.zhang@ibm.com>
+Ondřej Surý <ondrej@sury.org>
+Juan José Arboleda <soyjuanarbol@gmail.com>
+Zhao Zhili <zhilizhao@tencent.com>
+Brandon Cheng <brandon.cheng@protonmail.com>
+Matvii Hodovaniuk <matvii@hodovani.uk>
+Hayden <me@diatr.us>
+yiyuaner <yguoaz@gmail.com>
+bbara <bbara93@gmail.com>
+SeverinLeonhardt <Severin.Leonhardt@teamviewer.com>
+Andy Fiddaman <andy@omniosce.org>
+Romain Roffé <rofferom@gmail.com>
+Eagle Liang <eagleliang@gmail.com>
+Ricky Zhou <ives199511@gmail.com>
+Simon Kissane <skissane@gmail.com>
+James M Snell <jasnell@gmail.com>
+Ali Mohammad Pur <Ali.mpfard@gmail.com>
+Erkhes N <71805796+rexes-ND@users.noreply.github.com>
+Joshua M. Clulow <josh@sysmgr.org>
+Guilherme Íscaro <cabelitostos@gmail.com>
+Martin Storsjö <martin@martin.st>
+Claes Nästén <pekdon@gmail.com>
+Mohamed Edrah <43171151+MSE99@users.noreply.github.com>
+Supragya Raj <supragyaraj@gmail.com>
+Ikko Ashimine <eltociear@gmail.com>
+Sylvain Corlay <sylvain.corlay@gmail.com>
+earnal <etienne.arnal@gmail.com>
+YAKSH BARIYA <yakshbari4@gmail.com>
+Ofek Lev <ofekmeister@gmail.com>
+~locpyl-tidnyd <81016946+locpyl-tidnyd@users.noreply.github.com>
+Evan Miller <emmiller@gmail.com>
+Petr Menšík <pemensik@redhat.com>
+Nicolas Noble <nicolasnoble@users.noreply.github.com>
+AJ Heller <aj@drfloob.com>
+Stacey Marshall <stacey.marshall@gmail.com>
+Jesper Storm Bache <jsbache@users.noreply.github.com>
+Campbell He <duskmoon314@users.noreply.github.com>
+Andrey Hohutkin <andrey.hohutkin@gmail.com>
+deal <halx99@live.com>
+David Machaj <46852402+dmachaj@users.noreply.github.com>
+Jessica Clarke <jrtc27@jrtc27.com>
+Jeremy Rose <nornagon@nornagon.net>
+woclass <git@wo-class.cn>
+Luca Adrian L <info@lucalindhorst.de>
+WenTao Ou <owt5008137@live.com>
+jonilaitinen <joni.laitinen@iki.fi>
+UMU <UMU618@users.noreply.github.com>
+Paul Evans <leonerd@leonerd.org.uk>
+wyckster <wyckster@hotmail.com>
+Vittore F. Scolari <vittore.scolari@gmail.com>
+roflcopter4 <15476346+roflcopter4@users.noreply.github.com>
+V-for-Vasili <vasili.skurydzin@protonmail.com>
+Denny C. Dai <dennycd@me.com>
+Hannah Shi <hannahshisfb@gmail.com>
+tuftedocelot <tuftedocelot@fastmail.fm>
+blogdaren <blogdaren@163.com>
+chucksilvers <chuq@chuq.com>
+Sergey Fedorov <vital.had@gmail.com>
+theanarkh <2923878201@qq.com>
+Samuel Cabrero <samuelcabrero@gmail.com>
+自发对称破缺 <429839446@qq.com>
+Luan Devecchi <luan@engineer.com>
+Steven Schveighoffer <schveiguy@gmail.com>
+number201724 <number201724@me.com>
+Daniel <reymond315qq@gmail.com>
+Christian Clason <christian.clason@uni-due.de>
+ywave620 <rogertyang@tencent.com>
+jensbjorgensen <jbj1@ultraemail.net>
+daomingq <daoming.qiu@intel.com>
+Qix <Qix-@users.noreply.github.com>
+Edward Humes <29870961+aurxenon@users.noreply.github.com>
+Tim Besard <tim.besard@gmail.com>
+Sergey Rubanov <chi187@gmail.com>
+Stefan Stojanovic <StefanStojanovic@users.noreply.github.com>
+Zvicii <zvicii@qq.com>
+dundargoc <33953936+dundargoc@users.noreply.github.com>
+Jack·Boos·Yu <47264268+JackBoosY@users.noreply.github.com>
+panran <310762957@qq.com>
+Tamás Bálint Misius <lbphacker@gmail.com>
+Bruno Passeri <Varstahl@users.noreply.github.com>
+Jason Zhang <xzha4350@gmail.com>
+Lewis Russell <me@lewisr.dev>
+sivadeilra <arlie.davis@gmail.com>
+cui fliter <imcusg@gmail.com>
+Mohammed Keyvanzadeh <mohammadkeyvanzade94@gmail.com>
+Niklas Mischkulnig <4586894+mischnic@users.noreply.github.com>
+Stefan Karpinski <stefan@karpinski.org>
+liuxiang88 <94350585+liuxiang88@users.noreply.github.com>
+Jeffrey H. Johnson <trnsz@pobox.com>
+Abdirahim Musse <33973272+abmusse@users.noreply.github.com>
+小明 <7737673+caobug@users.noreply.github.com>
+Shuduo Sang <sangshuduo@gmail.com>
+Keith Winstein <keithw@cs.stanford.edu>
+michalbiesek <michalbiesek@gmail.com>
+Alois Klink <alois@aloisklink.com>
+SmorkalovG <smorkalov.g@gmail.com>
+Pleuvens <pleuvens.fervil@gmail.com>
+jolai <58589285+laijonathan@users.noreply.github.com>
+Julien Roncaglia <fox@vbfox.net>
+prubel <paul@rubels.net>
+Per Allansson <65364157+per-allansson@users.noreply.github.com>
+Matheus Izvekov <mizvekov@gmail.com>
+Christian Heimlich <chris@pcserenity.com>
+Hao Hu <33607772+hhu8@users.noreply.github.com>
+matoro <12038583+matoro@users.noreply.github.com>
+Bo Anderson <mail@boanderson.me>
+Ardi Nugraha <33378542+ardi-nugraha@users.noreply.github.com>
+Anton Bachin <antonbachin@yahoo.com>
+Trevor Flynn <trevorflynn@liquidcrystalstudios.com>
+Andy Pan <panjf2000@gmail.com>
+Viacheslav Muravyev <slavamuravey@mail.ru>
+Anthony Alayo <anthony.alayo@gmail.com>
+Thomas Walter <31201229+waltoss@users.noreply.github.com>
+hiiizxf <385122613@qq.com>
+Geddy <guandichao@163.com>
+Farzin Monsef <monseffarzin@gmail.com>
+tgolang <154592711+tgolang@users.noreply.github.com>
+josedelinux <josedelinux@hotmail.com>
+Hüseyin Açacak <110401522+huseyinacacak-janea@users.noreply.github.com>
+Uilian Ries <uilianries@gmail.com>
+Olivier Valentin <ovalenti@redhat.com>
+郑苏波 (Super Zheng) <superzheng@tencent.com>
+zeertzjq <zeertzjq@outlook.com>
+Ian Butterworth <i.r.butterworth@gmail.com>
+握猫猫 <164346864@qq.com>
+Zuohui Yang <274048862@qq.com>
+Edigleysson Silva (Edy) <edigleyssonsilva@gmail.com>
+Raihaan Shouhell <raihaanhimself@gmail.com>
+Rialbat <miha-wead@mail.ru>
+Adam <adam@NetBSD.org>
+Poul T Lomholt <ptlomholt@users.noreply.github.com>
+Thad House <ThadHouse@users.noreply.github.com>
+Julian A Avar C <28635807+julian-a-avar-c@users.noreply.github.com>
+amcgoogan <105525867+amcgoogan@users.noreply.github.com>
+Rafael Gonzaga <rafael.nunu@hotmail.com>
+Morten Engelhardt Olsen <moro.engelhardt@gmail.com>
+Andrey <bag@zurbagan.org>
+Julio Jordán <juliojjordanp@outlook.com>
+Jinho Jang <verycosy@kakao.com>
+Velikiy Kirill <kuklix@ya.ru>
+rainlow <37818892+rainlow@users.noreply.github.com>
+Paolo Insogna <paolo@cowtech.it>
+Robert Nagy <robert@openbsd.org>
+mugitya03 <mugitya233@outlook.com>
+Itay Bookstein <ibookstein@gmail.com>
+crupest <crupest@outlook.com>
+AE1020 <68134252+AE1020@users.noreply.github.com>

deps/uv/BUILD.gn

@@ -0,0 +1,14 @@
+##############################################################################
+#                                                                            #
+#                       DO NOT EDIT THIS FILE!                               #
+#                                                                            #
+##############################################################################
+
+# This file is used by GN for building, which is NOT the build system used for
+# building official binaries.
+# Please modify the gyp files if you are making changes to build system.
+
+import("unofficial.gni")
+
+uv_gn_build("uv") {
+}

deps/uv/CMakeLists.txt

@@ -0,0 +1,816 @@
+cmake_minimum_required(VERSION 3.10)
+
+if(POLICY CMP0091)
+  cmake_policy(SET CMP0091 NEW) # Enable MSVC_RUNTIME_LIBRARY setting
+endif()
+if(POLICY CMP0092)
+  cmake_policy(SET CMP0092 NEW) # disable /W3 warning, if possible
+endif()
+
+project(libuv LANGUAGES C)
+
+list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+
+include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
+include(CheckCCompilerFlag)
+include(GNUInstallDirs)
+include(CTest)
+
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_EXTENSIONS ON)
+set(CMAKE_C_STANDARD 11)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+option(LIBUV_BUILD_SHARED "Build shared lib" ON)
+
+cmake_dependent_option(LIBUV_BUILD_TESTS
+  "Build the unit tests when BUILD_TESTING is enabled and we are the root project" ON
+  "BUILD_TESTING;LIBUV_BUILD_SHARED;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
+cmake_dependent_option(LIBUV_BUILD_BENCH
+  "Build the benchmarks when building unit tests and we are the root project" ON
+  "LIBUV_BUILD_TESTS" OFF)
+
+# Qemu Build
+option(QEMU "build for qemu" OFF)
+if(QEMU)
+  list(APPEND uv_defines __QEMU__=1)
+endif()
+
+# Note: these are mutually exclusive.
+option(ASAN "Enable AddressSanitizer (ASan)" OFF)
+option(MSAN "Enable MemorySanitizer (MSan)" OFF)
+option(TSAN "Enable ThreadSanitizer (TSan)" OFF)
+option(UBSAN "Enable UndefinedBehaviorSanitizer (UBSan)" OFF)
+
+if(MSAN AND NOT CMAKE_C_COMPILER_ID MATCHES "AppleClang|Clang")
+  message(SEND_ERROR "MemorySanitizer requires clang. Try again with -DCMAKE_C_COMPILER=clang")
+endif()
+
+if(ASAN)
+  list(APPEND uv_defines __ASAN__=1)
+  if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang")
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+    set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address")
+  elseif(MSVC)
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /fsanitize=address")
+  else()
+    message(SEND_ERROR "AddressSanitizer support requires clang, gcc, or msvc. Try again with -DCMAKE_C_COMPILER.")
+  endif()
+endif()
+
+if(MSAN)
+  list(APPEND uv_defines __MSAN__=1)
+  set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=memory")
+  set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=memory")
+  set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=memory")
+endif()
+
+if(TSAN)
+  list(APPEND uv_defines __TSAN__=1)
+  if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang")
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=thread")
+    set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread")
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread")
+  else()
+    message(SEND_ERROR "ThreadSanitizer support requires clang or gcc. Try again with -DCMAKE_C_COMPILER.")
+  endif()
+endif()
+
+if(UBSAN)
+  cmake_minimum_required(VERSION 3.13)
+  list(APPEND uv_defines __UBSAN__=1)
+  if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang")
+    add_compile_options("-fsanitize=undefined" "-fno-sanitize-recover=undefined")
+    if (NOT WIN32)
+      add_link_options("-fsanitize=undefined")
+    endif()
+    if(MSVC)
+      add_compile_options("/Oy-")
+    else()
+      add_compile_options("-fno-omit-frame-pointer")
+    endif()
+  else()
+    message(SEND_ERROR "UndefinedBehaviorSanitizer support requires clang or gcc. Try again with -DCMAKE_C_COMPILER.")
+  endif()
+endif()
+
+# Compiler check
+string(CONCAT is-msvc $<OR:
+  $<C_COMPILER_ID:MSVC>,
+  $<STREQUAL:${CMAKE_C_COMPILER_FRONTEND_VARIANT},MSVC>
+>)
+
+check_c_compiler_flag(/W4 UV_LINT_W4)
+check_c_compiler_flag(/wd4100 UV_LINT_NO_UNUSED_PARAMETER_MSVC)
+check_c_compiler_flag(/wd4127 UV_LINT_NO_CONDITIONAL_CONSTANT_MSVC)
+check_c_compiler_flag(/wd4201 UV_LINT_NO_NONSTANDARD_MSVC)
+check_c_compiler_flag(/wd4206 UV_LINT_NO_NONSTANDARD_EMPTY_TU_MSVC)
+check_c_compiler_flag(/wd4210 UV_LINT_NO_NONSTANDARD_FILE_SCOPE_MSVC)
+check_c_compiler_flag(/wd4232 UV_LINT_NO_NONSTANDARD_NONSTATIC_DLIMPORT_MSVC)
+check_c_compiler_flag(/wd4456 UV_LINT_NO_HIDES_LOCAL)
+check_c_compiler_flag(/wd4457 UV_LINT_NO_HIDES_PARAM)
+check_c_compiler_flag(/wd4459 UV_LINT_NO_HIDES_GLOBAL)
+check_c_compiler_flag(/wd4706 UV_LINT_NO_CONDITIONAL_ASSIGNMENT_MSVC)
+check_c_compiler_flag(/wd4996 UV_LINT_NO_UNSAFE_MSVC)
+
+check_c_compiler_flag(-Wall UV_LINT_WALL) # DO NOT use this under MSVC
+
+# TODO: Place these into its own function
+check_c_compiler_flag(-Wno-unused-parameter UV_LINT_NO_UNUSED_PARAMETER)
+check_c_compiler_flag(-Wstrict-prototypes UV_LINT_STRICT_PROTOTYPES)
+check_c_compiler_flag(-Wextra UV_LINT_EXTRA)
+
+check_c_compiler_flag(/utf-8 UV_LINT_UTF8_MSVC)
+
+set(lint-no-unused-parameter $<$<BOOL:${UV_LINT_NO_UNUSED_PARAMETER}>:-Wno-unused-parameter>)
+set(lint-strict-prototypes $<$<BOOL:${UV_LINT_STRICT_PROTOTYPES}>:-Wstrict-prototypes>)
+set(lint-extra $<$<BOOL:${UV_LINT_EXTRA}>:-Wextra>)
+set(lint-w4 $<$<BOOL:${UV_LINT_W4}>:/W4>)
+set(lint-no-unused-parameter-msvc $<$<BOOL:${UV_LINT_NO_UNUSED_PARAMETER_MSVC}>:/wd4100>)
+set(lint-no-conditional-constant-msvc $<$<BOOL:${UV_LINT_NO_CONDITIONAL_CONSTANT_MSVC}>:/wd4127>)
+set(lint-no-nonstandard-msvc $<$<BOOL:${UV_LINT_NO_NONSTANDARD_MSVC}>:/wd4201>)
+set(lint-no-nonstandard-empty-tu-msvc $<$<BOOL:${UV_LINT_NO_NONSTANDARD_EMPTY_TU_MSVC}>:/wd4206>)
+set(lint-no-nonstandard-file-scope-msvc $<$<BOOL:${UV_LINT_NO_NONSTANDARD_FILE_SCOPE_MSVC}>:/wd4210>)
+set(lint-no-nonstandard-nonstatic-dlimport-msvc $<$<BOOL:${UV_LINT_NO_NONSTANDARD_NONSTATIC_DLIMPORT_MSVC}>:/wd4232>)
+set(lint-no-hides-local-msvc $<$<BOOL:${UV_LINT_NO_HIDES_LOCAL}>:/wd4456>)
+set(lint-no-hides-param-msvc $<$<BOOL:${UV_LINT_NO_HIDES_PARAM}>:/wd4457>)
+set(lint-no-hides-global-msvc $<$<BOOL:${UV_LINT_NO_HIDES_GLOBAL}>:/wd4459>)
+set(lint-no-conditional-assignment-msvc $<$<BOOL:${UV_LINT_NO_CONDITIONAL_ASSIGNMENT_MSVC}>:/wd4706>)
+set(lint-no-unsafe-msvc $<$<BOOL:${UV_LINT_NO_UNSAFE_MSVC}>:/wd4996>)
+# Unfortunately, this one is complicated because MSVC and clang-cl support -Wall
+# but using it is like calling -Weverything
+string(CONCAT lint-default $<
+  $<AND:$<BOOL:${UV_LINT_WALL}>,$<NOT:${is-msvc}>>:-Wall
+>)
+set(lint-utf8-msvc $<$<BOOL:${UV_LINT_UTF8_MSVC}>:/utf-8>)
+
+list(APPEND uv_cflags ${lint-strict-prototypes} ${lint-extra} ${lint-default} ${lint-w4})
+list(APPEND uv_cflags ${lint-no-unused-parameter})
+list(APPEND uv_cflags ${lint-no-unused-parameter-msvc})
+list(APPEND uv_cflags ${lint-no-conditional-constant-msvc})
+list(APPEND uv_cflags ${lint-no-nonstandard-msvc})
+list(APPEND uv_cflags ${lint-no-nonstandard-empty-tu-msvc})
+list(APPEND uv_cflags ${lint-no-nonstandard-file-scope-msvc})
+list(APPEND uv_cflags ${lint-no-nonstandard-nonstatic-dlimport-msvc})
+list(APPEND uv_cflags ${lint-no-hides-local-msvc})
+list(APPEND uv_cflags ${lint-no-hides-param-msvc})
+list(APPEND uv_cflags ${lint-no-hides-global-msvc})
+list(APPEND uv_cflags ${lint-no-conditional-assignment-msvc})
+list(APPEND uv_cflags ${lint-no-unsafe-msvc})
+list(APPEND uv_cflags ${lint-utf8-msvc} )
+
+check_c_compiler_flag(-fno-strict-aliasing UV_F_STRICT_ALIASING)
+list(APPEND uv_cflags $<$<BOOL:${UV_F_STRICT_ALIASING}>:-fno-strict-aliasing>)
+
+if (MSVC)
+  # Error on calling undeclared functions.
+  list(APPEND uv_cflags "/we4013")
+endif()
+
+set(uv_sources
+    src/fs-poll.c
+    src/idna.c
+    src/inet.c
+    src/random.c
+    src/strscpy.c
+    src/strtok.c
+    src/thread-common.c
+    src/threadpool.c
+    src/timer.c
+    src/uv-common.c
+    src/uv-data-getter-setters.c
+    src/version.c)
+
+if(WIN32)
+  list(APPEND uv_defines WIN32_LEAN_AND_MEAN _WIN32_WINNT=0x0A00 _CRT_DECLARE_NONSTDC_NAMES=0)
+  list(APPEND uv_libraries
+       psapi
+       user32
+       advapi32
+       iphlpapi
+       userenv
+       ws2_32
+       dbghelp
+       ole32
+       shell32)
+  list(APPEND uv_sources
+       src/win/async.c
+       src/win/core.c
+       src/win/detect-wakeup.c
+       src/win/dl.c
+       src/win/error.c
+       src/win/fs.c
+       src/win/fs-event.c
+       src/win/getaddrinfo.c
+       src/win/getnameinfo.c
+       src/win/handle.c
+       src/win/loop-watcher.c
+       src/win/pipe.c
+       src/win/thread.c
+       src/win/poll.c
+       src/win/process.c
+       src/win/process-stdio.c
+       src/win/signal.c
+       src/win/snprintf.c
+       src/win/stream.c
+       src/win/tcp.c
+       src/win/tty.c
+       src/win/udp.c
+       src/win/util.c
+       src/win/winapi.c
+       src/win/winsock.c)
+  list(APPEND uv_test_libraries ws2_32)
+  list(APPEND uv_test_sources src/win/snprintf.c test/runner-win.c)
+else()
+  list(APPEND uv_defines _FILE_OFFSET_BITS=64 _LARGEFILE_SOURCE)
+  if(NOT CMAKE_SYSTEM_NAME MATCHES "Android|OS390|QNX")
+    # TODO: This should be replaced with find_package(Threads) if possible
+    # Android has pthread as part of its c library, not as a separate
+    # libpthread.so.
+    list(APPEND uv_libraries pthread)
+  endif()
+  list(APPEND uv_sources
+       src/unix/async.c
+       src/unix/core.c
+       src/unix/dl.c
+       src/unix/fs.c
+       src/unix/getaddrinfo.c
+       src/unix/getnameinfo.c
+       src/unix/loop-watcher.c
+       src/unix/loop.c
+       src/unix/pipe.c
+       src/unix/poll.c
+       src/unix/process.c
+       src/unix/random-devurandom.c
+       src/unix/signal.c
+       src/unix/stream.c
+       src/unix/tcp.c
+       src/unix/thread.c
+       src/unix/tty.c
+       src/unix/udp.c)
+  list(APPEND uv_test_sources test/runner-unix.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "AIX")
+  list(APPEND uv_defines
+       _ALL_SOURCE
+       _LINUX_SOURCE_COMPAT
+       _THREAD_SAFE
+       _XOPEN_SOURCE=500
+       HAVE_SYS_AHAFS_EVPRODS_H)
+  list(APPEND uv_libraries perfstat)
+  list(APPEND uv_sources
+       src/unix/aix.c
+       src/unix/aix-common.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Android")
+  list(APPEND uv_defines _GNU_SOURCE)
+  list(APPEND uv_libraries dl)
+  list(APPEND uv_sources
+       src/unix/linux.c
+       src/unix/procfs-exepath.c
+       src/unix/random-getentropy.c
+       src/unix/random-getrandom.c
+       src/unix/random-sysctl-linux.c)
+endif()
+
+if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "Android|Linux")
+  list(APPEND uv_sources src/unix/proctitle.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
+  list(APPEND uv_sources src/unix/freebsd.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD|NetBSD|OpenBSD")
+  list(APPEND uv_sources src/unix/posix-hrtime.c src/unix/bsd-proctitle.c)
+endif()
+
+if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD|NetBSD|OpenBSD")
+  list(APPEND uv_sources src/unix/bsd-ifaddrs.c src/unix/kqueue.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+  list(APPEND uv_sources src/unix/random-getrandom.c)
+endif()
+
+if(APPLE OR CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+  list(APPEND uv_sources src/unix/random-getentropy.c)
+endif()
+
+if(APPLE)
+  list(APPEND uv_defines _DARWIN_UNLIMITED_SELECT=1 _DARWIN_USE_64_BIT_INODE=1)
+  list(APPEND uv_sources
+       src/unix/darwin-proctitle.c
+       src/unix/darwin.c
+       src/unix/fsevents.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "GNU")
+  list(APPEND uv_defines _GNU_SOURCE _POSIX_C_SOURCE=200112 _XOPEN_SOURCE=500)
+  list(APPEND uv_libraries dl)
+  list(APPEND uv_sources
+       src/unix/bsd-ifaddrs.c
+       src/unix/no-fsevents.c
+       src/unix/no-proctitle.c
+       src/unix/posix-hrtime.c
+       src/unix/posix-poll.c
+       src/unix/hurd.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  list(APPEND uv_defines _GNU_SOURCE _POSIX_C_SOURCE=200112)
+  list(APPEND uv_libraries dl rt)
+  list(APPEND uv_sources
+       src/unix/linux.c
+       src/unix/procfs-exepath.c
+       src/unix/random-getrandom.c
+       src/unix/random-sysctl-linux.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "NetBSD")
+  list(APPEND uv_sources src/unix/netbsd.c)
+  list(APPEND uv_libraries kvm)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
+  list(APPEND uv_sources src/unix/openbsd.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "OS390")
+  enable_language(CXX)
+  list(APPEND uv_defines PATH_MAX=1024)
+  list(APPEND uv_defines _AE_BIMODAL)
+  list(APPEND uv_defines _ALL_SOURCE)
+  list(APPEND uv_defines _ENHANCED_ASCII_EXT=0xFFFFFFFF)
+  list(APPEND uv_defines _ISOC99_SOURCE)
+  list(APPEND uv_defines _LARGE_TIME_API)
+  list(APPEND uv_defines _OPEN_MSGQ_EXT)
+  list(APPEND uv_defines _OPEN_SYS_FILE_EXT)
+  list(APPEND uv_defines _OPEN_SYS_IF_EXT)
+  list(APPEND uv_defines _OPEN_SYS_SOCK_EXT3)
+  list(APPEND uv_defines _OPEN_SYS_SOCK_IPV6)
+  list(APPEND uv_defines _UNIX03_SOURCE)
+  list(APPEND uv_defines _UNIX03_THREADS)
+  list(APPEND uv_defines _UNIX03_WITHDRAWN)
+  list(APPEND uv_defines _XOPEN_SOURCE=600)
+  list(APPEND uv_defines _XOPEN_SOURCE_EXTENDED)
+  list(APPEND uv_sources
+       src/unix/os390.c
+       src/unix/os390-syscalls.c
+       src/unix/os390-proctitle.c)
+  list(APPEND uv_cflags
+       -q64
+       -qascii
+       -qexportall
+       -qgonumber
+       -qlongname
+       -qlibansi
+       -qfloat=IEEE
+       -qtune=10
+       -qarch=10
+       -qasm
+       -qasmlib=sys1.maclib:sys1.modgen)
+  find_library(ZOSLIB
+    NAMES zoslib
+    PATHS ${ZOSLIB_DIR}
+    PATH_SUFFIXES lib
+  )
+  list(APPEND uv_libraries ${ZOSLIB})
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "OS400")
+  list(APPEND uv_defines
+       _ALL_SOURCE
+       _LINUX_SOURCE_COMPAT
+       _THREAD_SAFE
+       _XOPEN_SOURCE=500)
+  list(APPEND uv_sources
+    src/unix/aix-common.c
+    src/unix/ibmi.c
+    src/unix/no-fsevents.c
+    src/unix/posix-poll.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+  if(CMAKE_SYSTEM_VERSION STREQUAL "5.10")
+    list(APPEND uv_defines SUNOS_NO_IFADDRS)
+    list(APPEND uv_libraries rt)
+  endif()
+  list(APPEND uv_defines __EXTENSIONS__ _XOPEN_SOURCE=500 _REENTRANT)
+  list(APPEND uv_libraries kstat nsl sendfile socket)
+  list(APPEND uv_sources
+       src/unix/no-proctitle.c
+       src/unix/sunos.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Haiku")
+  list(APPEND uv_defines _BSD_SOURCE)
+  list(APPEND uv_libraries bsd network)
+  list(APPEND uv_sources
+	  src/unix/haiku.c
+	  src/unix/bsd-ifaddrs.c
+	  src/unix/no-fsevents.c
+	  src/unix/no-proctitle.c
+	  src/unix/posix-hrtime.c
+	  src/unix/posix-poll.c)
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "QNX")
+  list(APPEND uv_sources
+    src/unix/posix-hrtime.c
+    src/unix/posix-poll.c
+    src/unix/qnx.c
+    src/unix/bsd-ifaddrs.c
+    src/unix/no-proctitle.c
+    src/unix/no-fsevents.c)
+  list(APPEND uv_libraries socket)
+endif()
+
+if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD|Linux|NetBSD|OpenBSD")
+  list(APPEND uv_test_libraries util)
+  list(APPEND uv_libraries m)
+endif()
+
+if(CYGWIN OR MSYS)
+  list(APPEND uv_defines _GNU_SOURCE)
+  list(APPEND uv_sources
+       src/unix/cygwin.c
+       src/unix/bsd-ifaddrs.c
+       src/unix/no-fsevents.c
+       src/unix/no-proctitle.c
+       src/unix/posix-hrtime.c
+       src/unix/posix-poll.c
+       src/unix/procfs-exepath.c
+       src/unix/sysinfo-loadavg.c
+       src/unix/sysinfo-memory.c)
+endif()
+
+if(LIBUV_BUILD_SHARED)
+  add_library(uv SHARED ${uv_sources})
+  target_compile_definitions(uv
+    INTERFACE
+      USING_UV_SHARED=1
+    PRIVATE
+      BUILDING_UV_SHARED=1
+      ${uv_defines})
+  target_compile_options(uv PRIVATE ${uv_cflags})
+  target_include_directories(uv
+    PUBLIC
+      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+      $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+    PRIVATE
+      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>)
+  if(CMAKE_SYSTEM_NAME STREQUAL "OS390")
+    target_include_directories(uv PUBLIC $<BUILD_INTERFACE:${ZOSLIB_DIR}/include>)
+    set_target_properties(uv PROPERTIES LINKER_LANGUAGE CXX)
+  endif()
+  target_link_libraries(uv ${uv_libraries})
+  set_target_properties(uv PROPERTIES OUTPUT_NAME "uv")
+endif()
+
+add_library(uv_a STATIC ${uv_sources})
+target_compile_definitions(uv_a PRIVATE ${uv_defines})
+target_compile_options(uv_a PRIVATE ${uv_cflags})
+target_include_directories(uv_a
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>)
+if(CMAKE_SYSTEM_NAME STREQUAL "OS390")
+  target_include_directories(uv_a PUBLIC $<BUILD_INTERFACE:${ZOSLIB_DIR}/include>)
+  set_target_properties(uv_a PROPERTIES LINKER_LANGUAGE CXX)
+endif()
+target_link_libraries(uv_a ${uv_libraries})
+set_target_properties(uv_a PROPERTIES OUTPUT_NAME "uv")
+if(WIN32)
+  set_target_properties(uv_a PROPERTIES PREFIX "lib")
+endif()
+
+if(LIBUV_BUILD_TESTS)
+  # Small hack: use ${uv_test_sources} now to get the runner skeleton,
+  # before the actual tests are added.
+  add_executable(
+    uv_run_benchmarks_a
+    ${uv_test_sources}
+    test/benchmark-async-pummel.c
+    test/benchmark-async.c
+    test/benchmark-fs-stat.c
+    test/benchmark-getaddrinfo.c
+    test/benchmark-loop-count.c
+    test/benchmark-queue-work.c
+    test/benchmark-million-async.c
+    test/benchmark-million-timers.c
+    test/benchmark-multi-accept.c
+    test/benchmark-ping-pongs.c
+    test/benchmark-ping-udp.c
+    test/benchmark-pound.c
+    test/benchmark-pump.c
+    test/benchmark-sizes.c
+    test/benchmark-spawn.c
+    test/benchmark-tcp-write-batch.c
+    test/benchmark-thread.c
+    test/benchmark-udp-pummel.c
+    test/blackhole-server.c
+    test/echo-server.c
+    test/run-benchmarks.c
+    test/runner.c)
+  target_compile_definitions(uv_run_benchmarks_a PRIVATE ${uv_defines})
+  target_compile_options(uv_run_benchmarks_a PRIVATE ${uv_cflags})
+  target_link_libraries(uv_run_benchmarks_a uv_a ${uv_test_libraries})
+
+  list(APPEND uv_test_sources
+       test/blackhole-server.c
+       test/echo-server.c
+       test/run-tests.c
+       test/runner.c
+       test/test-active.c
+       test/test-async-null-cb.c
+       test/test-async.c
+       test/test-barrier.c
+       test/test-callback-stack.c
+       test/test-close-fd.c
+       test/test-close-order.c
+       test/test-condvar.c
+       test/test-connect-unspecified.c
+       test/test-connection-fail.c
+       test/test-cwd-and-chdir.c
+       test/test-default-loop-close.c
+       test/test-delayed-accept.c
+       test/test-dlerror.c
+       test/test-eintr-handling.c
+       test/test-embed.c
+       test/test-emfile.c
+       test/test-env-vars.c
+       test/test-error.c
+       test/test-fail-always.c
+       test/test-fork.c
+       test/test-fs-copyfile.c
+       test/test-fs-event.c
+       test/test-fs-poll.c
+       test/test-fs.c
+       test/test-fs-readdir.c
+       test/test-fs-fd-hash.c
+       test/test-fs-open-flags.c
+       test/test-get-currentexe.c
+       test/test-get-loadavg.c
+       test/test-get-memory.c
+       test/test-get-passwd.c
+       test/test-getaddrinfo.c
+       test/test-gethostname.c
+       test/test-getnameinfo.c
+       test/test-getsockname.c
+       test/test-getters-setters.c
+       test/test-gettimeofday.c
+       test/test-handle-fileno.c
+       test/test-homedir.c
+       test/test-hrtime.c
+       test/test-idle.c
+       test/test-idna.c
+       test/test-iouring-pollhup.c
+       test/test-ip4-addr.c
+       test/test-ip6-addr.c
+       test/test-ip-name.c
+       test/test-ipc-heavy-traffic-deadlock-bug.c
+       test/test-ipc-send-recv.c
+       test/test-ipc.c
+       test/test-loop-alive.c
+       test/test-loop-close.c
+       test/test-loop-configure.c
+       test/test-loop-handles.c
+       test/test-loop-oom.c
+       test/test-loop-stop.c
+       test/test-loop-time.c
+       test/test-metrics.c
+       test/test-multiple-listen.c
+       test/test-mutexes.c
+       test/test-not-readable-nor-writable-on-read-error.c
+       test/test-not-writable-after-shutdown.c
+       test/test-osx-select.c
+       test/test-pass-always.c
+       test/test-ping-pong.c
+       test/test-pipe-bind-error.c
+       test/test-pipe-close-stdout-read-stdin.c
+       test/test-pipe-connect-error.c
+       test/test-pipe-connect-multiple.c
+       test/test-pipe-connect-prepare.c
+       test/test-pipe-getsockname.c
+       test/test-pipe-pending-instances.c
+       test/test-pipe-sendmsg.c
+       test/test-pipe-server-close.c
+       test/test-pipe-set-fchmod.c
+       test/test-pipe-set-non-blocking.c
+       test/test-platform-output.c
+       test/test-poll-close-doesnt-corrupt-stack.c
+       test/test-poll-close.c
+       test/test-poll-closesocket.c
+       test/test-poll-multiple-handles.c
+       test/test-poll-oob.c
+       test/test-poll.c
+       test/test-process-priority.c
+       test/test-process-title-threadsafe.c
+       test/test-process-title.c
+       test/test-queue-foreach-delete.c
+       test/test-random.c
+       test/test-readable-on-eof.c
+       test/test-ref.c
+       test/test-run-nowait.c
+       test/test-run-once.c
+       test/test-semaphore.c
+       test/test-shutdown-close.c
+       test/test-shutdown-eof.c
+       test/test-shutdown-simultaneous.c
+       test/test-shutdown-twice.c
+       test/test-signal-multiple-loops.c
+       test/test-signal-pending-on-close.c
+       test/test-signal.c
+       test/test-socket-buffer-size.c
+       test/test-spawn.c
+       test/test-stdio-over-pipes.c
+       test/test-strscpy.c
+       test/test-strtok.c
+       test/test-tcp-alloc-cb-fail.c
+       test/test-tcp-bind-error.c
+       test/test-tcp-bind6-error.c
+       test/test-tcp-close-accept.c
+       test/test-tcp-close-after-read-timeout.c
+       test/test-tcp-close-while-connecting.c
+       test/test-tcp-close.c
+       test/test-tcp-close-reset.c
+       test/test-tcp-connect-error-after-write.c
+       test/test-tcp-connect-error.c
+       test/test-tcp-connect-timeout.c
+       test/test-tcp-connect6-error.c
+       test/test-tcp-create-socket-early.c
+       test/test-tcp-flags.c
+       test/test-tcp-oob.c
+       test/test-tcp-open.c
+       test/test-tcp-read-stop.c
+       test/test-tcp-reuseport.c
+       test/test-tcp-read-stop-start.c
+       test/test-tcp-rst.c
+       test/test-tcp-shutdown-after-write.c
+       test/test-tcp-try-write.c
+       test/test-tcp-write-in-a-row.c
+       test/test-tcp-try-write-error.c
+       test/test-tcp-unexpected-read.c
+       test/test-tcp-write-after-connect.c
+       test/test-tcp-write-fail.c
+       test/test-tcp-write-queue-order.c
+       test/test-tcp-write-to-half-open-connection.c
+       test/test-tcp-writealot.c
+       test/test-test-macros.c
+       test/test-thread-affinity.c
+       test/test-thread-equal.c
+       test/test-thread.c
+       test/test-thread-name.c
+       test/test-thread-priority.c
+       test/test-threadpool-cancel.c
+       test/test-threadpool.c
+       test/test-timer-again.c
+       test/test-timer-from-check.c
+       test/test-timer.c
+       test/test-tmpdir.c
+       test/test-tty-duplicate-key.c
+       test/test-tty-escape-sequence-processing.c
+       test/test-tty.c
+       test/test-udp-alloc-cb-fail.c
+       test/test-udp-bind.c
+       test/test-udp-connect.c
+       test/test-udp-connect6.c
+       test/test-udp-create-socket-early.c
+       test/test-udp-dgram-too-big.c
+       test/test-udp-ipv6.c
+       test/test-udp-mmsg.c
+       test/test-udp-multicast-interface.c
+       test/test-udp-multicast-interface6.c
+       test/test-udp-multicast-join.c
+       test/test-udp-multicast-join6.c
+       test/test-udp-multicast-ttl.c
+       test/test-udp-open.c
+       test/test-udp-options.c
+       test/test-udp-send-and-recv.c
+       test/test-udp-send-hang-loop.c
+       test/test-udp-send-immediate.c
+       test/test-udp-sendmmsg-error.c
+       test/test-udp-send-unreachable.c
+       test/test-udp-try-send.c
+       test/test-udp-recv-in-a-row.c
+       test/test-udp-reuseport.c
+       test/test-uname.c
+       test/test-walk-handles.c
+       test/test-watcher-cross-stop.c)
+
+  add_executable(uv_run_tests ${uv_test_sources} uv_win_longpath.manifest)
+  target_compile_definitions(uv_run_tests
+                             PRIVATE ${uv_defines} USING_UV_SHARED=1)
+  target_compile_options(uv_run_tests PRIVATE ${uv_cflags})
+  target_link_libraries(uv_run_tests uv ${uv_test_libraries})
+  add_test(NAME uv_test
+           COMMAND uv_run_tests
+           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if(CMAKE_SYSTEM_NAME STREQUAL "OS390")
+    set_tests_properties(uv_test PROPERTIES ENVIRONMENT
+                         "LIBPATH=${CMAKE_BINARY_DIR}:$ENV{LIBPATH}")
+  endif()
+  if(WIN32)
+    add_custom_command(TARGET uv_run_tests POST_BUILD
+                       COMMAND "${CMAKE_COMMAND}" -E copy
+                       "$<TARGET_FILE:uv_run_tests>"
+                       "$<TARGET_FILE_DIR:uv_run_tests>/uv_run_tests_no_ext")
+  endif()
+  add_executable(uv_run_tests_a ${uv_test_sources} uv_win_longpath.manifest)
+  target_compile_definitions(uv_run_tests_a PRIVATE ${uv_defines})
+  target_compile_options(uv_run_tests_a PRIVATE ${uv_cflags})
+  if(QEMU)
+    target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries} -static)
+  else()
+    target_link_libraries(uv_run_tests_a uv_a ${uv_test_libraries})
+  endif()
+  add_test(NAME uv_test_a
+           COMMAND uv_run_tests_a
+           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  if(CMAKE_SYSTEM_NAME STREQUAL "OS390")
+    set_target_properties(uv_run_benchmarks_a PROPERTIES LINKER_LANGUAGE CXX)
+    set_target_properties(uv_run_tests PROPERTIES LINKER_LANGUAGE CXX)
+    set_target_properties(uv_run_tests_a PROPERTIES LINKER_LANGUAGE CXX)
+  endif()
+  if(WIN32)
+    add_custom_command(TARGET uv_run_tests_a POST_BUILD
+                       COMMAND "${CMAKE_COMMAND}" -E copy
+                       "$<TARGET_FILE:uv_run_tests_a>"
+                       "$<TARGET_FILE_DIR:uv_run_tests_a>/uv_run_tests_a_no_ext")
+  endif()
+endif()
+
+# Now for some gibbering horrors from beyond the stars...
+foreach(lib IN LISTS uv_libraries)
+  list(APPEND LIBS "-l${lib}")
+endforeach()
+string(REPLACE ";" " " LIBS "${LIBS}")
+# Consider setting project version via project() call?
+file(STRINGS configure.ac configure_ac REGEX ^AC_INIT)
+string(REGEX MATCH "([0-9]+)[.][0-9]+[.][0-9]+" PACKAGE_VERSION "${configure_ac}")
+set(UV_VERSION_MAJOR "${CMAKE_MATCH_1}")
+
+set(includedir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR})
+set(libdir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR})
+set(prefix ${CMAKE_INSTALL_PREFIX})
+configure_file(libuv-static.pc.in libuv-static.pc @ONLY)
+
+install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR})
+install(FILES LICENSE-extra DESTINATION ${CMAKE_INSTALL_DOCDIR})
+install(FILES ${PROJECT_BINARY_DIR}/libuv-static.pc
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+install(TARGETS uv_a EXPORT libuvConfig
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(EXPORT libuvConfig
+	DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libuv
+	NAMESPACE libuv::)
+
+if(LIBUV_BUILD_SHARED)
+  # The version in the filename is mirroring the behaviour of autotools.
+  set_target_properties(uv PROPERTIES
+          VERSION ${UV_VERSION_MAJOR}.0.0
+          SOVERSION ${UV_VERSION_MAJOR})
+  configure_file(libuv.pc.in libuv.pc @ONLY)
+  install(FILES ${PROJECT_BINARY_DIR}/libuv.pc
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+  install(TARGETS uv EXPORT libuvConfig
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+          LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+endif()
+
+if(MSVC)
+  set(CMAKE_DEBUG_POSTFIX d)
+  get_filename_component(CMAKE_C_COMPILER_DIR ${CMAKE_C_COMPILER} DIRECTORY)
+  if(ASAN)
+    file(INSTALL "${CMAKE_C_COMPILER_DIR}/llvm-symbolizer.exe" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
+    file(INSTALL "${CMAKE_C_COMPILER_DIR}/clang_rt.asan_dynamic-x86_64.dll" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
+    file(INSTALL "${CMAKE_C_COMPILER_DIR}/clang_rt.asan_dbg_dynamic-x86_64.dll" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
+  endif()
+endif()
+
+if(BUILD_SHARED_LIBS)
+  set(LIB_SELECTED uv)
+else()
+  set(LIB_SELECTED uv_a)
+endif()
+
+add_library(libuv::libuv ALIAS ${LIB_SELECTED})
+
+message(STATUS "summary of build options:
+    Install prefix:  ${CMAKE_INSTALL_PREFIX}
+    Target system:   ${CMAKE_SYSTEM_NAME}
+    Compiler:
+      C compiler:    ${CMAKE_C_COMPILER} (${CMAKE_C_COMPILER_ID})
+      CFLAGS:        ${CMAKE_C_FLAGS_${_build_type}} ${CMAKE_C_FLAGS}
+")

deps/uv/CONTRIBUTING.md

@@ -0,0 +1,171 @@
+# CONTRIBUTING
+
+The libuv project welcomes new contributors. This document will guide you
+through the process.
+
+
+### FORK
+
+Fork the project [on GitHub](https://github.com/libuv/libuv) and check out
+your copy.
+
+```
+$ git clone https://github.com/username/libuv.git
+$ cd libuv
+$ git remote add upstream https://github.com/libuv/libuv.git
+```
+
+Now decide if you want your feature or bug fix to go into the master branch
+or the stable branch.  As a rule of thumb, bug fixes go into the stable branch
+while new features go into the master branch.
+
+The stable branch is effectively frozen; patches that change the libuv
+API/ABI or affect the run-time behavior of applications get rejected.
+
+In case of doubt, open an issue in the [issue tracker][], post your question
+to the [libuv discussions forum], or message the [libuv mailing list].
+
+Especially do so if you plan to work on something big. Nothing is more
+frustrating than seeing your hard work go to waste because your vision does not
+align with that of the [project maintainers].
+
+
+### BRANCH
+
+Okay, so you have decided on the proper branch.  Create a feature branch
+and start hacking:
+
+```
+$ git checkout -b my-feature-branch -t origin/v1.x
+```
+
+(Where v1.x is the latest stable branch as of this writing.)
+
+### CODE
+
+Please adhere to libuv's code style. In general it follows the conventions from
+the [Google C/C++ style guide]. Some of the key points, as well as some
+additional guidelines, are enumerated below.
+
+* Code that is specific to unix-y platforms should be placed in `src/unix`, and
+  declarations go into `include/uv/unix.h`.
+
+* Source code that is Windows-specific goes into `src/win`, and related
+  publicly exported types, functions and macro declarations should generally
+  be declared in `include/uv/win.h`.
+
+* Names should be descriptive and concise.
+
+* All the symbols and types that libuv makes available publicly should be
+  prefixed with `uv_` (or `UV_` in case of macros).
+
+* Internal, non-static functions should be prefixed with `uv__`.
+
+* Use two spaces and no tabs.
+
+* Lines should be wrapped at 80 characters.
+
+* Ensure that lines have no trailing whitespace, and use unix-style (LF) line
+  endings.
+
+* Use C89-compliant syntax. In other words, variables can only be declared at
+  the top of a scope (function, if/for/while-block).
+
+* When writing comments, use properly constructed sentences, including
+  punctuation.
+
+* When documenting APIs and/or source code, don't make assumptions or make
+  implications about race, gender, religion, political orientation or anything
+  else that isn't relevant to the project.
+
+* Remember that source code usually gets written once and read often: ensure
+  the reader doesn't have to make guesses. Make sure that the purpose and inner
+  logic are either obvious to a reasonably skilled professional, or add a
+  comment that explains it.
+
+
+### COMMIT
+
+Make sure git knows your name and email address:
+
+```
+$ git config --global user.name "J. Random User"
+$ git config --global user.email "j.random.user@example.com"
+```
+
+Writing good commit logs is important.  A commit log should describe what
+changed and why.  Follow these guidelines when writing one:
+
+1. The first line should be 50 characters or less and contain a short
+   description of the change prefixed with the name of the changed
+   subsystem (e.g. "net: add localAddress and localPort to Socket").
+2. Keep the second line blank.
+3. Wrap all other lines at 72 columns.
+
+A good commit log looks like this:
+
+```
+subsystem: explaining the commit in one line
+
+Body of commit message is a few lines of text, explaining things
+in more detail, possibly giving some background about the issue
+being fixed, etc etc.
+
+The body of the commit message can be several paragraphs, and
+please do proper word-wrap and keep columns shorter than about
+72 characters or so. That way `git log` will show things
+nicely even when it is indented.
+```
+
+The header line should be meaningful; it is what other people see when they
+run `git shortlog` or `git log --oneline`.
+
+Check the output of `git log --oneline files_that_you_changed` to find out
+what subsystem (or subsystems) your changes touch.
+
+
+### REBASE
+
+Use `git rebase` (not `git merge`) to sync your work from time to time.
+
+```
+$ git fetch upstream
+$ git rebase upstream/v1.x  # or upstream/master
+```
+
+
+### TEST
+
+Bug fixes and features should come with tests.  Add your tests in the
+`test/` directory. Each new test needs to be registered in `test/test-list.h`.
+
+If you add a new test file, it needs to be registered in three places:
+- `CMakeLists.txt`: add the file's name to the `uv_test_sources` list.
+- `Makefile.am`: add the file's name to the `test_run_tests_SOURCES` list.
+
+Look at other tests to see how they should be structured (license boilerplate,
+the way entry points are declared, etc.).
+
+Check README.md file to find out how to run the test suite and make sure that
+there are no test regressions.
+
+### PUSH
+
+```
+$ git push origin my-feature-branch
+```
+
+Go to https://github.com/username/libuv and select your feature branch.  Click
+the 'Pull Request' button and fill out the form.
+
+Pull requests are usually reviewed within a few days.  If there are comments
+to address, apply your changes in a separate commit and push that to your
+feature branch.  Post a comment in the pull request afterwards; GitHub does
+not send out notifications when you add commits.
+
+
+[issue tracker]: https://github.com/libuv/libuv/issues
+[libuv mailing list]: http://groups.google.com/group/libuv
+[libuv discussions forum]: https://github.com/libuv/libuv/discussions
+[Google C/C++ style guide]: https://google.github.io/styleguide/cppguide.html
+[project maintainers]: https://github.com/libuv/libuv/blob/master/MAINTAINERS.md

deps/uv/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-present libuv project contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

deps/uv/LICENSE-docs

@@ -0,0 +1,396 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More_considerations
+     for the public: 
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+

deps/uv/LICENSE-extra

@@ -0,0 +1,36 @@
+This license applies to parts of libuv originating from the
+https://github.com/joyent/libuv repository:
+
+====
+
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+
+====
+
+This license applies to all parts of libuv that are not externally
+maintained libraries.
+
+The externally maintained libraries used by libuv are:
+
+  - tree.h (from FreeBSD), copyright Niels Provos. Two clause BSD license.
+
+  - inet_pton and inet_ntop implementations, contained in src/inet.c, are
+    copyright the Internet Systems Consortium, Inc., and licensed under the ISC
+    license.

deps/uv/LINKS.md

@@ -0,0 +1,112 @@
+### Apps / VM
+* [AliceO2](https://github.com/AliceO2Group/AliceO2): The framework and detector specific code for the reconstruction, calibration and simulation for the ALICE experiment at CERN.
+* [Beam](https://github.com/BeamMW/beam): A scalable, confidential cryptocurrency based on the Mimblewimble protocol.
+* [BIND 9](https://bind.isc.org/): DNS software system including an authoritative server, a recursive resolver and related utilities.
+* [cjdns](https://github.com/cjdelisle/cjdns): Encrypted self-configuring network/VPN routing engine
+* [clearskies_core](https://github.com/larroy/clearskies_core): Clearskies file synchronization program. (C++11)
+* [CMake](https://cmake.org) open-source, cross-platform family of tools designed to build, test and package software
+* [Cocos-Engine](https://github.com/cocos/cocos-engine): The runtime framework for Cocos Creator editor.
+* [Coherence](https://github.com/liesware/coherence/): Cryptographic server for modern web apps.
+* [DPS8M](https://dps8m.gitlab.io): GE ∕ Honeywell ∕ Bull DPS‑8/M and 6180/L68 mainframe simulator.
+* [DPS-For-IoT](https://github.com/intel/dps-for-iot/wiki): Fully distributed publish/subscribe protocol.
+* [HashLink](https://github.com/HaxeFoundation/hashlink): Haxe run-time with libuv support included.
+* [Haywire](https://github.com/kellabyte/Haywire): Asynchronous HTTP server.
+* [H2O](https://github.com/h2o/h2o): An optimized HTTP server with support for HTTP/1.x and HTTP/2.
+* [Igropyr](https://github.com/guenchi/Igropyr): a async Scheme http server base on libuv.
+* [Julia](http://julialang.org/): Scientific computing programming language
+* [Kestrel](https://github.com/dotnet/aspnetcore/tree/main/src/Servers/Kestrel): web server (C# + libuv + [ASP.NET Core](http://github.com/aspnet))
+* [Knot DNS Resolver](https://www.knot-resolver.cz/): A minimalistic DNS caching resolver
+* [Lever](http://leverlanguage.com): runtime, libuv at the 0.9.0 release
+* [libnode](https://github.com/plenluno/libnode): C++ implementation of Node.js
+* [libstorj](https://github.com/Storj/libstorj): Library for interacting with Storj network
+* [libuv_message_framing](https://github.com/litesync/libuv_message_framing) Message-based communication for libuv
+* [luaw](https://github.com/raksoras/luaw): Lua web server backed by libuv
+* [Luvit](http://luvit.io): Node.JS for the Lua Inventor
+* [mo](https://github.com/wehu/mo): Scheme (guile) + libuv runtime
+* [MoarVM](https://github.com/MoarVM/MoarVM): a VM for [Rakudo](http://rakudo.org/) [Raku](http://raku.org)
+* [Mysocks](https://github.com/zhou0/mysocks): a cross-platform [Shadowsocks](https://shadowsocks.org) client
+* [mediasoup](http://mediasoup.org): Powerful WebRTC SFU for Node.js
+* [Neovim](https://neovim.io/): A major refactor of Vim.
+* [node9](https://github.com/jvburnes/node9): A portable, hybrid, distributed OS based on Inferno, LuaJIT and Libuv
+* [node.js](http://www.nodejs.org/): Javascript (using Google's V8) + libuv
+* [node.native](https://github.com/d5/node.native): node.js-like API for C++11
+* [nodeuv](https://github.com/nodeuv): An organization with several c++ wrappers for libs which are used in node.js.
+* [phastlight](https://github.com/phastlight/phastlight): Command line tool and web server written in PHP 5.3+ inspired by Node.js
+* [pilight](https://www.pilight.org/): home automation ("domotica")
+* [pixie](https://github.com/pixie-lang/pixie): clojure-inspired lisp with a tracing JIT
+* [Pixie-io](https://github.com/pixie-io/pixie): Open-source observability tool for Kubernetes applications.
+* [potion](https://github.com/perl11/potion)/[p2](https://github.com/perl11/p2): runtime
+* [racer](https://libraries.io/rubygems/racer): Ruby web server written as an C extension
+* [scala-native-loop](https://github.com/scala-native/scala-native-loop): Extensible event loop and async-oriented IO for Scala Native; powered by libuv
+* [Socket Runtime](https://sockets.sh): A runtime for creating native cross-platform software on mobile and desktop using HTML, CSS, and JavaScript
+* [spider-gazelle](https://github.com/cotag/spider-gazelle): Ruby web server using libuv bindings
+* [Suave](http://suave.io/): A simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition
+* [Swish](https://github.com/becls/swish/): Concurrency engine with Erlang-like concepts. Includes a web server.
+* [Trevi](https://github.com/Yoseob/Trevi): A powerful Swift Web Application Server Framework Project
+* [Urbit](http://urbit.org): runtime
+* [uv_callback](https://github.com/litesync/uv_callback) libuv thread communication
+* [uvloop](https://github.com/MagicStack/uvloop): Ultra fast implementation of python's asyncio event loop on top of libuv
+* [WPILib](https://github.com/wpilibsuite/allwpilib): Libraries for creating robot programs for the roboRIO.
+* [Wren CLI](https://github.com/wren-lang/wren-cli): For io, process, scheduler and timer modules
+
+### Other
+* [libtuv](https://github.com/Samsung/libtuv): libuv fork for IoT and embedded systems
+
+### Bindings
+* [Ring](http://ring-lang.net)
+   * [RingLibuv](http://ring-lang.sourceforge.net/doc1.7/libuv.html)
+* Ruby
+   * [libuv](https://github.com/cotag/libuv)
+   * [uvrb](https://github.com/avalanche123/uvrb)
+   * [ruv](https://github.com/aq1018/ruv)
+   * [rbuv](https://github.com/rbuv/rbuv)
+   * [mruby-uv](https://github.com/mattn/mruby-uv): mruby binding
+* Lua
+   * [luv](https://github.com/creationix/luv)
+   * [lev](https://github.com/connectFree/lev)
+   * [lluv](https://github.com/moteus/lua-lluv)
+* C++11
+   * [uvpp](https://github.com/larroy/uvpp) - Not complete, exposes very few aspects of `libuv`
+   * [nsuv](https://github.com/nodesource/nsuv) - Template wrapper focused on enforcing compile-time type safety when propagating data
+* C++17
+   * [uvw](https://github.com/skypjack/uvw) - Header-only, event based, tiny and easy to use *libuv* wrapper in modern C++.
+* Python
+   * [Pyuv](https://github.com/saghul/pyuv)
+   * [uvloop](https://github.com/MagicStack/uvloop) - Ultra fast asyncio event loop.
+   * [gevent](http://www.gevent.org) - Coroutine-based concurrency library for Python
+* C#
+   * [NetUV](http://github.com/StormHub/NetUV)
+   * [LibuvSharp](http://github.com/txdv/LibuvSharp)
+* Perl 5
+   * [UV](https://metacpan.org/pod/UV)
+* [Raku](https://raku.org/)
+   * [MoarVM](https://github.com/MoarVM/MoarVM) [uses](http://6guts.wordpress.com/2013/05/31/moarvm-a-virtual-machine-for-nqp-and-rakudo/) libuv
+* PHP
+   * [php-uv](https://github.com/bwoebi/php-uv)
+* Go
+   * [go-uv](https://github.com/mattn/go-uv)
+* OCaml
+   * [luv](https://github.com/aantron/luv)
+   * [uwt](https://github.com/fdopen/uwt)
+* ooc
+   * [ooc-uv](https://github.com/nddrylliog/ooc-uv)
+* dylan
+   * [uv-dylan](https://github.com/waywardmonkeys/uv-dylan)
+* R
+   * [httpuv](https://github.com/rstudio/httpuv): HTTP and WebSocket server library for R
+   * [fs](https://fs.r-lib.org/): Cross-platform file system operations
+* Java
+   * [libuv-java](https://java.net/projects/avatar-js/sources/libuv-java/show): Java bindings
+* Nim
+   * [nimuv](https://github.com/2vg/nimuv): Nim bindings
+* Lisp
+   * [cl-libuv](https://github.com/orthecreedence/cl-libuv) Common Lisp bindings
+   * [cl-async](https://github.com/orthecreedence/cl-async) Common Lisp async abstraction on top of cl-libuv
+* [Céu](http://www.ceu-lang.org)
+   * [Céu-libuv](https://github.com/fsantanna/ceu-libuv)
+* Delphi
+   * [node.pas](https://github.com/vovach777/node.pas) NodeJS-like ecosystem
+* Haskell
+   * [Z.Haskell](https://z.haskell.world)
+* C3
+   * [libuv.c3l](https://github.com/velikoss/libuv.c3l)   

deps/uv/MAINTAINERS.md

@@ -0,0 +1,56 @@
+# Project Maintainers
+
+libuv is currently managed by the following individuals:
+
+* **Ben Noordhuis** ([@bnoordhuis](https://github.com/bnoordhuis))
+  - GPG key: D77B 1E34 243F BAF0 5F8E  9CC3 4F55 C8C8 46AB 89B9 (pubkey-bnoordhuis)
+* **Colin Ihrig** ([@cjihrig](https://github.com/cjihrig))
+  - GPG key: 94AE 3667 5C46 4D64 BAFA  68DD 7434 390B DBE9 B9C5 (pubkey-cjihrig)
+  - GPG key: 5735 3E0D BDAA A7E8 39B6  6A1A FF47 D5E4 AD8B 4FDC (pubkey-cjihrig-kb)
+* **Jameson Nash** ([@vtjnash](https://github.com/vtjnash))
+  - GPG key: AEAD 0A4B 6867 6775 1A0E  4AEF 34A2 5FB1 2824 6514 (pubkey-vtjnash)
+  - GPG key: CFBB 9CA9 A5BE AFD7 0E2B  3C5A 79A6 7C55 A367 9C8B (pubkey2022-vtjnash)
+* **Jiawen Geng** ([@gengjiawen](https://github.com/gengjiawen))
+* **Kaoru Takanashi** ([@erw7](https://github.com/erw7))
+  - GPG Key: 5804 F999 8A92 2AFB A398  47A0 7183 5090 6134 887F (pubkey-erw7)
+* **Richard Lau** ([@richardlau](https://github.com/richardlau))
+  - GPG key: C82F A3AE 1CBE DC6B E46B  9360 C43C EC45 C17A B93C (pubkey-richardlau)
+* **Santiago Gimeno** ([@santigimeno](https://github.com/santigimeno))
+  - GPG key: 612F 0EAD 9401 6223 79DF  4402 F28C 3C8D A33C 03BE (pubkey-santigimeno)
+* **Saúl Ibarra Corretgé** ([@saghul](https://github.com/saghul))
+  - GPG key: FDF5 1936 4458 319F A823  3DC9 410E 5553 AE9B C059 (pubkey-saghul)
+* **Trevor Norris** ([@trevnorris](https://github.com/trevnorris))
+  - GPG key: AEFC 279A 0C93 0676 7E58  29A1 251C A676 820D C7F3 (pubkey-trevnorris)
+
+## Project Maintainers emeriti
+
+* **Anna Henningsen** ([@addaleax](https://github.com/addaleax))
+* **Bartosz Sosnowski** ([@bzoz](https://github.com/bzoz))
+* **Bert Belder** ([@piscisaureus](https://github.com/piscisaureus))
+* **Fedor Indutny** ([@indutny](https://github.com/indutny))
+  - GPG key: AF2E EA41 EC34 47BF DD86  FED9 D706 3CCE 19B7 E890 (pubkey-indutny)
+* **Imran Iqbal** ([@imran-iq](https://github.com/imran-iq))
+* **John Barboza** ([@jbarz](https://github.com/jbarz))
+
+## Storing a maintainer key in Git
+
+It's quite handy to store a maintainer's signature as a git blob, and have
+that object tagged and signed with such key.
+
+Export your public key:
+
+    $ gpg --armor --export saghul@gmail.com > saghul.asc
+
+Store it as a blob on the repo:
+
+    $ git hash-object -w saghul.asc
+
+The previous command returns a hash, copy it. For the sake of this explanation,
+we'll assume it's 'abcd1234'. Storing the blob in git is not enough, it could
+be garbage collected since nothing references it, so we'll create a tag for it:
+
+    $ git tag -s pubkey-saghul abcd1234
+
+Commit the changes and push:
+
+    $ git push origin pubkey-saghul

deps/uv/Makefile.am

@@ -0,0 +1,563 @@
+# Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CPPFLAGS = -I$(top_srcdir)/include \
+              -I$(top_srcdir)/src
+
+include_HEADERS=include/uv.h
+
+uvincludedir = $(includedir)/uv
+uvinclude_HEADERS = include/uv/errno.h \
+                    include/uv/threadpool.h \
+                    include/uv/version.h
+
+CLEANFILES =
+
+lib_LTLIBRARIES = libuv.la
+libuv_la_CFLAGS = $(AM_CFLAGS)
+libuv_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined -version-info 1:0:0
+libuv_la_SOURCES = src/fs-poll.c \
+                   src/heap-inl.h \
+                   src/idna.c \
+                   src/idna.h \
+                   src/inet.c \
+                   src/queue.h \
+                   src/random.c \
+                   src/strscpy.c \
+                   src/strscpy.h \
+                   src/thread-common.c \
+                   src/threadpool.c \
+                   src/timer.c \
+                   src/uv-data-getter-setters.c \
+                   src/uv-common.c \
+                   src/uv-common.h \
+                   src/version.c \
+                   src/strtok.c \
+                   src/strtok.h
+
+if SUNOS
+# Can't be turned into a CC_CHECK_CFLAGS in configure.ac, it makes compilers
+# on other platforms complain that the argument is unused during compilation.
+libuv_la_CFLAGS += -pthreads
+endif
+
+if WINNT
+
+uvinclude_HEADERS += include/uv/win.h include/uv/tree.h
+AM_CPPFLAGS += -I$(top_srcdir)/src/win \
+               -DWIN32_LEAN_AND_MEAN \
+               -D_WIN32_WINNT=0x0A00
+libuv_la_SOURCES += src/win/async.c \
+                    src/win/atomicops-inl.h \
+                    src/win/core.c \
+                    src/win/detect-wakeup.c \
+                    src/win/dl.c \
+                    src/win/error.c \
+                    src/win/fs-event.c \
+                    src/win/fs.c \
+                    src/win/getaddrinfo.c \
+                    src/win/getnameinfo.c \
+                    src/win/handle.c \
+                    src/win/handle-inl.h \
+                    src/win/internal.h \
+                    src/win/loop-watcher.c \
+                    src/win/pipe.c \
+                    src/win/poll.c \
+                    src/win/process-stdio.c \
+                    src/win/process.c \
+                    src/win/req-inl.h \
+                    src/win/signal.c \
+                    src/win/stream.c \
+                    src/win/stream-inl.h \
+                    src/win/tcp.c \
+                    src/win/thread.c \
+                    src/win/tty.c \
+                    src/win/udp.c \
+                    src/win/util.c \
+                    src/win/winapi.c \
+                    src/win/winapi.h \
+                    src/win/winsock.c \
+                    src/win/winsock.h
+
+else  # WINNT
+
+uvinclude_HEADERS += include/uv/unix.h
+AM_CPPFLAGS += -I$(top_srcdir)/src/unix
+libuv_la_SOURCES += src/unix/async.c \
+                   src/unix/core.c \
+                   src/unix/dl.c \
+                   src/unix/fs.c \
+                   src/unix/getaddrinfo.c \
+                   src/unix/getnameinfo.c \
+                   src/unix/internal.h \
+                   src/unix/loop-watcher.c \
+                   src/unix/loop.c \
+                   src/unix/pipe.c \
+                   src/unix/poll.c \
+                   src/unix/process.c \
+                   src/unix/random-devurandom.c \
+                   src/unix/signal.c \
+                   src/unix/stream.c \
+                   src/unix/tcp.c \
+                   src/unix/thread.c \
+                   src/unix/tty.c \
+                   src/unix/udp.c
+
+endif  # WINNT
+
+EXTRA_DIST = test/fixtures/empty_file \
+             test/fixtures/load_error.node \
+             test/fixtures/lorem_ipsum.txt \
+             test/fixtures/one_file/one_file \
+             include \
+             docs \
+             img \
+             CONTRIBUTING.md \
+             LICENSE \
+             LICENSE-extra \
+             README.md
+
+
+
+TESTS = test/run-tests
+check_PROGRAMS = test/run-tests
+test_run_tests_CFLAGS = $(AM_CFLAGS)
+
+if WINNT
+check-am: test/run-tests_no_ext
+test/run-tests_no_ext: test/run-tests$(EXEEXT)
+	cp test/run-tests$(EXEEXT) test/run-tests_no_ext
+endif
+
+if SUNOS
+# Can't be turned into a CC_CHECK_CFLAGS in configure.ac, it makes compilers
+# on other platforms complain that the argument is unused during compilation.
+test_run_tests_CFLAGS += -pthreads
+endif
+
+test_run_tests_LDFLAGS = $(AM_LDFLAGS)
+test_run_tests_SOURCES = test/blackhole-server.c \
+                         test/echo-server.c \
+                         test/run-tests.c \
+                         test/runner.c \
+                         test/runner.h \
+                         test/task.h \
+                         test/test-active.c \
+                         test/test-async.c \
+                         test/test-async-null-cb.c \
+                         test/test-barrier.c \
+                         test/test-callback-stack.c \
+                         test/test-close-fd.c \
+                         test/test-close-order.c \
+                         test/test-condvar.c \
+                         test/test-connect-unspecified.c \
+                         test/test-connection-fail.c \
+                         test/test-cwd-and-chdir.c \
+                         test/test-default-loop-close.c \
+                         test/test-delayed-accept.c \
+                         test/test-dlerror.c \
+                         test/test-eintr-handling.c \
+                         test/test-embed.c \
+                         test/test-emfile.c \
+                         test/test-env-vars.c \
+                         test/test-error.c \
+                         test/test-fail-always.c \
+                         test/test-fs-copyfile.c \
+                         test/test-fs-event.c \
+                         test/test-fs-poll.c \
+                         test/test-fs.c \
+                         test/test-fs-readdir.c \
+                         test/test-fs-fd-hash.c \
+                         test/test-fs-open-flags.c \
+                         test/test-fork.c \
+                         test/test-getters-setters.c \
+                         test/test-get-currentexe.c \
+                         test/test-get-loadavg.c \
+                         test/test-get-memory.c \
+                         test/test-get-passwd.c \
+                         test/test-getaddrinfo.c \
+                         test/test-gethostname.c \
+                         test/test-getnameinfo.c \
+                         test/test-getsockname.c \
+                         test/test-gettimeofday.c \
+                         test/test-handle-fileno.c \
+                         test/test-homedir.c \
+                         test/test-hrtime.c \
+                         test/test-idle.c \
+                         test/test-idna.c \
+                         test/test-iouring-pollhup.c \
+                         test/test-ip4-addr.c \
+                         test/test-ip6-addr.c \
+                         test/test-ip-name.c \
+                         test/test-ipc-heavy-traffic-deadlock-bug.c \
+                         test/test-ipc-send-recv.c \
+                         test/test-ipc.c \
+                         test/test-list.h \
+                         test/test-loop-alive.c \
+                         test/test-loop-close.c \
+                         test/test-loop-configure.c \
+                         test/test-loop-handles.c \
+                         test/test-loop-oom.c \
+                         test/test-loop-stop.c \
+                         test/test-loop-time.c \
+                         test/test-metrics.c \
+                         test/test-multiple-listen.c \
+                         test/test-mutexes.c \
+                         test/test-not-readable-nor-writable-on-read-error.c \
+                         test/test-not-writable-after-shutdown.c \
+                         test/test-osx-select.c \
+                         test/test-pass-always.c \
+                         test/test-ping-pong.c \
+                         test/test-pipe-bind-error.c \
+                         test/test-pipe-connect-error.c \
+                         test/test-pipe-connect-multiple.c \
+                         test/test-pipe-connect-prepare.c \
+                         test/test-pipe-getsockname.c \
+                         test/test-pipe-pending-instances.c \
+                         test/test-pipe-sendmsg.c \
+                         test/test-pipe-server-close.c \
+                         test/test-pipe-close-stdout-read-stdin.c \
+                         test/test-pipe-set-non-blocking.c \
+                         test/test-pipe-set-fchmod.c \
+                         test/test-platform-output.c \
+                         test/test-poll.c \
+                         test/test-poll-close.c \
+                         test/test-poll-close-doesnt-corrupt-stack.c \
+                         test/test-poll-closesocket.c \
+                         test/test-poll-multiple-handles.c \
+                         test/test-poll-oob.c \
+                         test/test-process-priority.c \
+                         test/test-process-title.c \
+                         test/test-process-title-threadsafe.c \
+                         test/test-queue-foreach-delete.c \
+                         test/test-random.c \
+                         test/test-readable-on-eof.c \
+                         test/test-ref.c \
+                         test/test-run-nowait.c \
+                         test/test-run-once.c \
+                         test/test-semaphore.c \
+                         test/test-shutdown-close.c \
+                         test/test-shutdown-eof.c \
+                         test/test-shutdown-simultaneous.c \
+                         test/test-shutdown-twice.c \
+                         test/test-signal-multiple-loops.c \
+                         test/test-signal-pending-on-close.c \
+                         test/test-signal.c \
+                         test/test-socket-buffer-size.c \
+                         test/test-spawn.c \
+                         test/test-stdio-over-pipes.c \
+                         test/test-strscpy.c \
+                         test/test-strtok.c \
+                         test/test-tcp-alloc-cb-fail.c \
+                         test/test-tcp-bind-error.c \
+                         test/test-tcp-bind6-error.c \
+                         test/test-tcp-close-accept.c \
+                         test/test-tcp-close-while-connecting.c \
+                         test/test-tcp-close-after-read-timeout.c \
+                         test/test-tcp-close.c \
+                         test/test-tcp-close-reset.c \
+                         test/test-tcp-create-socket-early.c \
+                         test/test-tcp-connect-error-after-write.c \
+                         test/test-tcp-connect-error.c \
+                         test/test-tcp-connect-timeout.c \
+                         test/test-tcp-connect6-error.c \
+                         test/test-tcp-flags.c \
+                         test/test-tcp-open.c \
+                         test/test-tcp-read-stop.c \
+                         test/test-tcp-reuseport.c \
+                         test/test-tcp-read-stop-start.c \
+                         test/test-tcp-rst.c \
+                         test/test-tcp-shutdown-after-write.c \
+                         test/test-tcp-unexpected-read.c \
+                         test/test-tcp-oob.c \
+                         test/test-tcp-write-to-half-open-connection.c \
+                         test/test-tcp-write-after-connect.c \
+                         test/test-tcp-writealot.c \
+                         test/test-tcp-write-fail.c \
+                         test/test-tcp-try-write.c \
+                         test/test-tcp-write-in-a-row.c \
+                         test/test-tcp-try-write-error.c \
+                         test/test-tcp-write-queue-order.c \
+                         test/test-test-macros.c \
+                         test/test-thread-equal.c \
+                         test/test-thread.c \
+                         test/test-thread-affinity.c \
+                         test/test-thread-name.c \
+                         test/test-thread-priority.c \
+                         test/test-threadpool-cancel.c \
+                         test/test-threadpool.c \
+                         test/test-timer-again.c \
+                         test/test-timer-from-check.c \
+                         test/test-timer.c \
+                         test/test-tmpdir.c \
+                         test/test-tty-duplicate-key.c \
+                         test/test-tty-escape-sequence-processing.c \
+                         test/test-tty.c \
+                         test/test-udp-alloc-cb-fail.c \
+                         test/test-udp-bind.c \
+                         test/test-udp-connect.c \
+                         test/test-udp-connect6.c \
+                         test/test-udp-create-socket-early.c \
+                         test/test-udp-dgram-too-big.c \
+                         test/test-udp-ipv6.c \
+                         test/test-udp-mmsg.c \
+                         test/test-udp-multicast-interface.c \
+                         test/test-udp-multicast-interface6.c \
+                         test/test-udp-multicast-join.c \
+                         test/test-udp-multicast-join6.c \
+                         test/test-udp-multicast-ttl.c \
+                         test/test-udp-open.c \
+                         test/test-udp-options.c \
+                         test/test-udp-send-and-recv.c \
+                         test/test-udp-send-hang-loop.c \
+                         test/test-udp-send-immediate.c \
+                         test/test-udp-sendmmsg-error.c \
+                         test/test-udp-send-unreachable.c \
+                         test/test-udp-try-send.c \
+                         test/test-udp-recv-in-a-row.c \
+                         test/test-udp-reuseport.c \
+                         test/test-uname.c \
+                         test/test-walk-handles.c \
+                         test/test-watcher-cross-stop.c
+test_run_tests_LDADD = libuv.la
+
+if WINNT
+test_run_tests_SOURCES += test/runner-win.c \
+                          test/runner-win.h
+else
+test_run_tests_SOURCES += test/runner-unix.c \
+                          test/runner-unix.h
+endif
+
+if AIX
+test_run_tests_CFLAGS += -D_ALL_SOURCE \
+                         -D_XOPEN_SOURCE=500 \
+                         -D_LINUX_SOURCE_COMPAT
+endif
+
+if OS400
+test_run_tests_CFLAGS += -D_ALL_SOURCE \
+                         -D_XOPEN_SOURCE=500 \
+                         -D_LINUX_SOURCE_COMPAT
+endif
+
+if HAIKU
+test_run_tests_CFLAGS += -D_BSD_SOURCE
+endif
+
+if LINUX
+test_run_tests_CFLAGS += -D_GNU_SOURCE
+endif
+
+if SUNOS
+test_run_tests_CFLAGS += -D__EXTENSIONS__ \
+                         -D_XOPEN_SOURCE=500 \
+                         -D_REENTRANT
+endif
+
+if OS390
+test_run_tests_CFLAGS += -D_ISOC99_SOURCE \
+                         -D_UNIX03_THREADS \
+                         -D_UNIX03_SOURCE \
+                         -D_OPEN_SYS_IF_EXT=1 \
+                         -D_OPEN_SYS_SOCK_IPV6 \
+                         -D_OPEN_MSGQ_EXT \
+                         -D_XOPEN_SOURCE_EXTENDED \
+                         -D_ALL_SOURCE \
+                         -D_LARGE_TIME_API \
+                         -D_OPEN_SYS_FILE_EXT \
+                         -DPATH_MAX=255 \
+                         -qCHARS=signed \
+                         -qXPLINK \
+                         -qFLOAT=IEEE
+endif
+
+if AIX
+libuv_la_CFLAGS += -D_ALL_SOURCE \
+                   -D_XOPEN_SOURCE=500 \
+                   -D_LINUX_SOURCE_COMPAT \
+                   -D_THREAD_SAFE \
+                   -DHAVE_SYS_AHAFS_EVPRODS_H
+uvinclude_HEADERS += include/uv/aix.h
+libuv_la_SOURCES += src/unix/aix.c src/unix/aix-common.c
+endif
+
+if OS400
+libuv_la_CFLAGS += -D_ALL_SOURCE \
+                   -D_XOPEN_SOURCE=500 \
+                   -D_LINUX_SOURCE_COMPAT \
+                   -D_THREAD_SAFE
+uvinclude_HEADERS += include/uv/posix.h
+libuv_la_SOURCES += src/unix/aix-common.c \
+                    src/unix/ibmi.c \
+                    src/unix/posix-poll.c \
+                    src/unix/no-fsevents.c
+endif
+
+if ANDROID
+libuv_la_CFLAGS += -D_GNU_SOURCE
+endif
+
+if CYGWIN
+uvinclude_HEADERS += include/uv/posix.h
+libuv_la_CFLAGS += -D_GNU_SOURCE
+libuv_la_SOURCES += src/unix/cygwin.c \
+                    src/unix/bsd-ifaddrs.c \
+                    src/unix/no-fsevents.c \
+                    src/unix/no-proctitle.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/posix-poll.c \
+                    src/unix/procfs-exepath.c \
+                    src/unix/sysinfo-loadavg.c \
+                    src/unix/sysinfo-memory.c
+endif
+
+if DARWIN
+uvinclude_HEADERS += include/uv/darwin.h
+libuv_la_CFLAGS += -D_DARWIN_USE_64_BIT_INODE=1
+libuv_la_CFLAGS += -D_DARWIN_UNLIMITED_SELECT=1
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/darwin-proctitle.c \
+                    src/unix/darwin-stub.h \
+                    src/unix/darwin-syscalls.h \
+                    src/unix/darwin.c \
+                    src/unix/fsevents.c \
+                    src/unix/kqueue.c \
+                    src/unix/proctitle.c \
+                    src/unix/random-getentropy.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if DRAGONFLY
+uvinclude_HEADERS += include/uv/bsd.h
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/bsd-proctitle.c \
+                    src/unix/freebsd.c \
+                    src/unix/kqueue.c \
+                    src/unix/posix-hrtime.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if FREEBSD
+uvinclude_HEADERS += include/uv/bsd.h
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/bsd-proctitle.c \
+                    src/unix/freebsd.c \
+                    src/unix/kqueue.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/random-getrandom.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if HAIKU
+uvinclude_HEADERS += include/uv/posix.h
+libuv_la_CFLAGS += -D_BSD_SOURCE
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/haiku.c \
+                    src/unix/no-fsevents.c \
+                    src/unix/no-proctitle.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/posix-poll.c
+endif
+
+if HURD
+uvinclude_HEADERS += include/uv/posix.h
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/no-fsevents.c \
+                    src/unix/no-proctitle.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/posix-poll.c \
+                    src/unix/hurd.c
+endif
+
+if LINUX
+uvinclude_HEADERS += include/uv/linux.h
+libuv_la_CFLAGS += -D_GNU_SOURCE
+libuv_la_SOURCES += src/unix/linux.c \
+                    src/unix/procfs-exepath.c \
+                    src/unix/proctitle.c \
+                    src/unix/random-getrandom.c \
+                    src/unix/random-sysctl-linux.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if MSYS
+libuv_la_CFLAGS += -D_GNU_SOURCE
+libuv_la_SOURCES += src/unix/cygwin.c \
+                    src/unix/bsd-ifaddrs.c \
+                    src/unix/no-fsevents.c \
+                    src/unix/no-proctitle.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/posix-poll.c \
+                    src/unix/procfs-exepath.c \
+                    src/unix/sysinfo-loadavg.c \
+                    src/unix/sysinfo-memory.c
+endif
+
+if NETBSD
+uvinclude_HEADERS += include/uv/bsd.h
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/bsd-proctitle.c \
+                    src/unix/kqueue.c \
+                    src/unix/netbsd.c \
+                    src/unix/posix-hrtime.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if OPENBSD
+uvinclude_HEADERS += include/uv/bsd.h
+libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \
+                    src/unix/bsd-proctitle.c \
+                    src/unix/kqueue.c \
+                    src/unix/openbsd.c \
+                    src/unix/posix-hrtime.c \
+                    src/unix/random-getentropy.c
+test_run_tests_LDFLAGS += -lutil
+endif
+
+if SUNOS
+uvinclude_HEADERS += include/uv/sunos.h
+libuv_la_CFLAGS += -D__EXTENSIONS__ \
+                   -D_XOPEN_SOURCE=500 \
+                   -D_REENTRANT
+libuv_la_SOURCES += src/unix/no-proctitle.c \
+                    src/unix/sunos.c
+endif
+
+if OS390
+libuv_la_CFLAGS += -D_UNIX03_THREADS \
+                   -D_UNIX03_SOURCE \
+                   -D_OPEN_SYS_IF_EXT=1 \
+                   -D_OPEN_MSGQ_EXT \
+                   -D_XOPEN_SOURCE_EXTENDED \
+                   -D_ALL_SOURCE \
+                   -D_LARGE_TIME_API \
+                   -D_OPEN_SYS_SOCK_EXT3 \
+                   -D_OPEN_SYS_SOCK_IPV6 \
+                   -D_OPEN_SYS_FILE_EXT \
+                   -DUV_PLATFORM_SEM_T=int \
+                   -DPATH_MAX=255 \
+                   -qCHARS=signed \
+                   -qXPLINK \
+                   -qFLOAT=IEEE
+libuv_la_LDFLAGS += -qXPLINK
+libuv_la_SOURCES += src/unix/os390.c \
+                    src/unix/os390-syscalls.c \
+                    src/unix/proctitle.c
+endif
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = @PACKAGE_NAME@.pc

deps/uv/README.md

@@ -0,0 +1,355 @@
+![libuv][libuv_banner]
+
+## Overview
+
+libuv is a multi-platform support library with a focus on asynchronous I/O. It
+was primarily developed for use by [Node.js][], but it's also
+used by [Luvit](http://luvit.io/), [Julia](http://julialang.org/),
+[uvloop](https://github.com/MagicStack/uvloop), and [others](https://github.com/libuv/libuv/blob/v1.x/LINKS.md).
+
+## Feature highlights
+
+ * Full-featured event loop backed by epoll, kqueue, IOCP, event ports.
+
+ * Asynchronous TCP and UDP sockets
+
+ * Asynchronous DNS resolution
+
+ * Asynchronous file and file system operations
+
+ * File system events
+
+ * ANSI escape code controlled TTY
+
+ * IPC with socket sharing, using Unix domain sockets or named pipes (Windows)
+
+ * Child processes
+
+ * Thread pool
+
+ * Signal handling
+
+ * High resolution clock
+
+ * Threading and synchronization primitives
+
+## Versioning
+
+Starting with version 1.0.0 libuv follows the [semantic versioning](http://semver.org/)
+scheme. The API change and backwards compatibility rules are those indicated by
+SemVer. libuv will keep a stable ABI across major releases.
+
+The ABI/API changes can be tracked [here](http://abi-laboratory.pro/tracker/timeline/libuv/).
+
+## Licensing
+
+libuv is licensed under the MIT license. Check the [LICENSE](LICENSE) and
+[LICENSE-extra](LICENSE-extra) files.
+
+The documentation is licensed under the CC BY 4.0 license. Check the
+[LICENSE-docs file](LICENSE-docs).
+
+## Community
+
+ * [Support](https://github.com/libuv/libuv/discussions)
+ * [Mailing list](http://groups.google.com/group/libuv)
+
+## Documentation
+
+### Official documentation
+
+Located in the docs/ subdirectory. It uses the [Sphinx](http://sphinx-doc.org/)
+framework, which makes it possible to build the documentation in multiple
+formats.
+
+Show different supported building options:
+
+```bash
+$ make help
+```
+
+Build documentation as HTML:
+
+```bash
+$ make html
+```
+
+Build documentation as HTML and live reload it when it changes (this requires
+sphinx-autobuild to be installed and is only supported on Unix):
+
+```bash
+$ make livehtml
+```
+
+Build documentation as man pages:
+
+```bash
+$ make man
+```
+
+Build documentation as ePub:
+
+```bash
+$ make epub
+```
+
+NOTE: Windows users need to use make.bat instead of plain 'make'.
+
+Documentation can be browsed online [here](http://docs.libuv.org).
+
+The [tests and benchmarks](https://github.com/libuv/libuv/tree/master/test)
+also serve as API specification and usage examples.
+
+### Other resources
+
+ * [LXJS 2012 talk](http://www.youtube.com/watch?v=nGn60vDSxQ4)
+   — High-level introductory talk about libuv.
+ * [libuv-dox](https://github.com/thlorenz/libuv-dox)
+   — Documenting types and methods of libuv, mostly by reading uv.h.
+ * [learnuv](https://github.com/thlorenz/learnuv)
+   — Learn uv for fun and profit, a self guided workshop to libuv.
+
+These resources are not handled by libuv maintainers and might be out of
+date. Please verify it before opening new issues.
+
+## Downloading
+
+libuv can be downloaded either from the
+[GitHub repository](https://github.com/libuv/libuv)
+or from the [downloads site](http://dist.libuv.org/dist/).
+
+Before verifying the git tags or signature files, importing the relevant keys
+is necessary. Key IDs are listed in the
+[MAINTAINERS](https://github.com/libuv/libuv/blob/master/MAINTAINERS.md)
+file, but are also available as git blob objects for easier use.
+
+Importing a key the usual way:
+
+```bash
+$ gpg --keyserver pool.sks-keyservers.net --recv-keys AE9BC059
+```
+
+Importing a key from a git blob object:
+
+```bash
+$ git show pubkey-saghul | gpg --import
+```
+
+### Verifying releases
+
+Git tags are signed with the developer's key, they can be verified as follows:
+
+```bash
+$ git verify-tag v1.6.1
+```
+
+Starting with libuv 1.7.0, the tarballs stored in the
+[downloads site](http://dist.libuv.org/dist/) are signed and an accompanying
+signature file sit alongside each. Once both the release tarball and the
+signature file are downloaded, the file can be verified as follows:
+
+```bash
+$ gpg --verify libuv-1.7.0.tar.gz.sign
+```
+
+## Build Instructions
+
+For UNIX-like platforms, including macOS, there are two build methods:
+autotools or [CMake][].
+
+For Windows, [CMake][] is the only supported build method and has the
+following prerequisites:
+
+<details>
+
+* One of:
+  * [Visual C++ Build Tools][]
+  * [Visual Studio 2015 Update 3][], all editions
+    including the Community edition (remember to select
+    "Common Tools for Visual C++ 2015" feature during installation).
+  * [Visual Studio 2017][], any edition (including the Build Tools SKU).
+    **Required Components:** "MSbuild", "VC++ 2017 v141 toolset" and one of the
+    Windows SDKs (10 or 8.1).
+* Basic Unix tools required for some tests,
+  [Git for Windows][] includes Git Bash
+  and tools which can be included in the global `PATH`.
+
+</details>
+
+To build with autotools:
+
+```bash
+$ sh autogen.sh
+$ ./configure
+$ make
+$ make check
+$ make install
+```
+
+To build with [CMake][]:
+
+```bash
+$ cmake -B build -DBUILD_TESTING=ON         # generate project with tests
+$ cmake --build build                       # add `-j <n>` with cmake >= 3.12
+
+# Run tests:
+$ (cd build && ctest -C Debug --output-on-failure)
+
+# Or manually run tests:
+$ build/uv_run_tests                        # shared library build
+$ build/uv_run_tests_a                      # static library build
+```
+
+To cross-compile with [CMake][] (unsupported but generally works):
+
+```bash
+$ cmake ../..                 \
+  -DCMAKE_SYSTEM_NAME=Windows \
+  -DCMAKE_SYSTEM_VERSION=6.1  \
+  -DCMAKE_C_COMPILER=i686-w64-mingw32-gcc
+```
+
+### Install with Homebrew
+
+```bash
+$ brew install --HEAD libuv
+```
+
+Note to OS X users:
+
+Make sure that you specify the architecture you wish to build for in the
+"ARCHS" flag. You can specify more than one by delimiting with a space
+(e.g. "x86_64 i386").
+
+### Install with vcpkg
+
+```bash
+$ git clone https://github.com/microsoft/vcpkg.git
+$ ./bootstrap-vcpkg.bat # for powershell
+$ ./bootstrap-vcpkg.sh # for bash
+$ ./vcpkg install libuv
+```
+
+### Install with Conan
+
+You can install pre-built binaries for libuv or build it from source using [Conan](https://conan.io/). Use the following command:
+
+```bash
+conan install --requires="libuv/[*]" --build=missing
+```
+
+The libuv Conan recipe is kept up to date by Conan maintainers and community contributors.
+If the version is out of date, please [create an issue or pull request](https://github.com/conan-io/conan-center-index) on the ConanCenterIndex repository.
+
+
+### Running tests
+
+Some tests are timing sensitive. Relaxing test timeouts may be necessary
+on slow or overloaded machines:
+
+```bash
+$ env UV_TEST_TIMEOUT_MULTIPLIER=2 build/uv_run_tests # 10s instead of 5s
+```
+
+#### Run one test
+
+The list of all tests is in `test/test-list.h`.
+
+This invocation will cause the test driver to fork and execute `TEST_NAME` in
+a child process:
+
+```bash
+$ build/uv_run_tests_a TEST_NAME
+```
+
+This invocation will cause the test driver to execute the test in
+the same process:
+
+```bash
+$ build/uv_run_tests_a TEST_NAME TEST_NAME
+```
+
+#### Debugging tools
+
+When running the test from within the test driver process
+(`build/uv_run_tests_a TEST_NAME TEST_NAME`), tools like gdb and valgrind
+work normally.
+
+When running the test from a child of the test driver process
+(`build/uv_run_tests_a TEST_NAME`), use these tools in a fork-aware manner.
+
+##### Fork-aware gdb
+
+Use the [follow-fork-mode](https://sourceware.org/gdb/onlinedocs/gdb/Forks.html) setting:
+
+```
+$ gdb --args build/uv_run_tests_a TEST_NAME
+
+(gdb) set follow-fork-mode child
+...
+```
+
+##### Fork-aware valgrind
+
+Use the `--trace-children=yes` parameter:
+
+```bash
+$ valgrind --trace-children=yes -v --tool=memcheck --leak-check=full --track-origins=yes --leak-resolution=high --show-reachable=yes --log-file=memcheck-%p.log build/uv_run_tests_a TEST_NAME
+```
+
+### Running benchmarks
+
+See the section on running tests.
+The benchmark driver is `./uv_run_benchmarks_a` and the benchmarks are
+listed in `test/benchmark-list.h`.
+
+## Supported Platforms
+
+Check the [SUPPORTED_PLATFORMS file](SUPPORTED_PLATFORMS.md).
+
+### `-fno-strict-aliasing`
+
+It is recommended to turn on the `-fno-strict-aliasing` compiler flag in
+projects that use libuv. The use of ad hoc "inheritance" in the libuv API
+may not be safe in the presence of compiler optimizations that depend on
+strict aliasing.
+
+MSVC does not have an equivalent flag but it also does not appear to need it
+at the time of writing (December 2019.)
+
+### AIX Notes
+
+AIX compilation using IBM XL C/C++ requires version 12.1 or greater.
+
+AIX support for filesystem events requires the non-default IBM `bos.ahafs`
+package to be installed.  This package provides the AIX Event Infrastructure
+that is detected by `autoconf`.
+[IBM documentation](http://www.ibm.com/developerworks/aix/library/au-aix_event_infrastructure/)
+describes the package in more detail.
+
+### z/OS Notes
+
+z/OS compilation requires [ZOSLIB](https://github.com/ibmruntimes/zoslib) to be installed. When building with [CMake][], use the flag `-DZOSLIB_DIR` to specify the path to [ZOSLIB](https://github.com/ibmruntimes/zoslib):
+
+```bash
+$ (cd build && cmake .. -DBUILD_TESTING=ON -DZOSLIB_DIR=/path/to/zoslib)
+$ cmake --build build
+```
+
+z/OS creates System V semaphores and message queues. These persist on the system
+after the process terminates unless the event loop is closed.
+
+Use the `ipcrm` command to manually clear up System V resources.
+
+## Patches
+
+See the [guidelines for contributing][].
+
+[CMake]: https://cmake.org/
+[node.js]: http://nodejs.org/
+[guidelines for contributing]: https://github.com/libuv/libuv/blob/master/CONTRIBUTING.md
+[libuv_banner]: https://raw.githubusercontent.com/libuv/libuv/master/img/banner.png
+[Visual C++ Build Tools]: https://visualstudio.microsoft.com/visual-cpp-build-tools/
+[Visual Studio 2015 Update 3]: https://www.visualstudio.com/vs/older-downloads/
+[Visual Studio 2017]: https://www.visualstudio.com/downloads/
+[Git for Windows]: http://git-scm.com/download/win

deps/uv/SECURITY.md

@@ -0,0 +1,27 @@
+# Security Policy
+
+## Supported Versions
+
+Currently, we are providing security updates for the latest release in the v1.x series:
+
+| Version | Supported          |
+| ------- | ------------------ |
+| Latest v1.x  | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+If you believe you have found a security vulnerability in `libuv`, please use the [GitHub's private vulnerability reporting feature](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability) in the [libuv repository](https://github.com/libuv/libuv) to report it to us.
+
+This will allow us to assess the risk, and make a fix available before we add a bug report to the GitHub repository.
+
+Please do:
+
+* Provide as much information as you can about the vulnerability.
+* Provide details about your configuration and environment, if applicable.
+
+Please do not:
+
+* Post any information about the vulnerability in public places.
+* Attempt to exploit the vulnerability yourself.
+
+We take all security bugs seriously. Thank you for improving the security of `libuv`. We appreciate your efforts and responsible disclosure and will make every effort to acknowledge your contributions.

deps/uv/SUPPORTED_PLATFORMS.md

@@ -0,0 +1,68 @@
+# Supported platforms
+
+|  System | Support type | Supported versions | Notes |
+|---|---|---|---|
+| GNU/Linux | Tier 1 | Linux >= 3.10 with glibc >= 2.17 | |
+| macOS | Tier 1 | macOS >= 11 | Currently supported macOS releases |
+| Windows | Tier 1 | >= Windows 10 | VS 2017 and later are supported |
+| FreeBSD | Tier 2 | >= 12 | |
+| AIX | Tier 2 | >= 6 | Maintainers: @libuv/aix |
+| IBM i | Tier 2 | >= IBM i 7.2 | Maintainers: @libuv/ibmi |
+| z/OS | Tier 2 | >= V2R2 | Maintainers: @libuv/zos |
+| Linux with musl | Tier 2 | musl >= 1.0 | |
+| Android | Tier 3 | NDK >= r15b | Android 7.0, `-DANDROID_PLATFORM=android-24` |
+| MinGW | Tier 3 | MinGW-w64 | |
+| SunOS | Tier 3 | Solaris 121 and later | |
+| Other | Tier 3 | N/A | |
+
+## Support types
+
+* **Tier 1**: Officially supported and tested with CI. Any contributed patch
+  MUST NOT break such systems. These are supported by @libuv/collaborators.
+
+* **Tier 2**: Officially supported, but not necessarily tested with CI. These
+  systems are maintained to the best of @libuv/collaborators ability,
+  without being a top priority.
+
+* **Tier 3**: Community maintained. These systems may inadvertently break and the
+  community and interested parties are expected to help with the maintenance.
+
+## Adding support for a new platform
+
+**IMPORTANT**: Before attempting to add support for a new platform please open
+an issue about it for discussion.
+
+### Unix
+
+I/O handling is abstracted by an internal `uv__io_t` handle. The new platform
+will need to implement some of the functions, the prototypes are in
+``src/unix/internal.h``.
+
+If the new platform requires extra fields for any handle structure, create a
+new include file in ``include/`` with the name ``uv-theplatform.h`` and add
+the appropriate defines there.
+
+All functionality related to the new platform must be implemented in its own
+file inside ``src/unix/`` unless it's already done in a common file, in which
+case adding an `ifdef` is fine.
+
+Two build systems are supported: autotools and cmake. Ideally both need to be
+supported, but if one of the two does not support the new platform it can be
+left out.
+
+### Windows
+
+Windows is treated as a single platform, so adding support for a new platform
+would mean adding support for a new version.
+
+Compilation and runtime must succeed for the minimum supported version. If a
+new API is to be used, it must be done optionally, only in supported versions.
+
+### Common
+
+Some common notes when adding support for new platforms:
+
+* Generally libuv tries to avoid compile time checks. Do not add any to the
+  autotools based build system or use version checking macros.
+  Dynamically load functions and symbols if they are not supported by the
+  minimum supported version.

deps/uv/autogen.sh

@@ -0,0 +1,75 @@
+#!/bin/sh
+
+# Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+set -eu
+cd `dirname "$0"`
+
+if [ "${1:-dev}" = "release" ]; then
+    export LIBUV_RELEASE=true
+else
+    export LIBUV_RELEASE=false
+fi
+
+if [ "${LIBTOOLIZE:-}" = "" ] && [ "`uname`" = "Darwin" ]; then
+  LIBTOOLIZE=glibtoolize
+fi
+
+ACLOCAL=${ACLOCAL:-aclocal}
+AUTOCONF=${AUTOCONF:-autoconf}
+AUTOMAKE=${AUTOMAKE:-automake}
+LIBTOOLIZE=${LIBTOOLIZE:-libtoolize}
+
+aclocal_version=`"$ACLOCAL" --version | head -n 1 | sed 's/[^.0-9]//g'`
+autoconf_version=`"$AUTOCONF" --version | head -n 1 | sed 's/[^.0-9]//g'`
+automake_version=`"$AUTOMAKE" --version | head -n 1 | sed 's/[^.0-9]//g'`
+automake_version_major=`echo "$automake_version" | cut -d. -f1`
+automake_version_minor=`echo "$automake_version" | cut -d. -f2`
+libtoolize_version=`"$LIBTOOLIZE" --version | head -n 1 | sed 's/[^.0-9]//g'`
+
+if [ $aclocal_version != $automake_version ]; then
+    echo "FATAL: aclocal version appears not to be from the same as automake"
+    exit 1
+fi
+
+UV_EXTRA_AUTOMAKE_FLAGS=
+if test "$automake_version_major" -gt 1 || \
+   test "$automake_version_major" -eq 1 && \
+   test "$automake_version_minor" -gt 11; then
+  # serial-tests is available in v1.12 and newer.
+  UV_EXTRA_AUTOMAKE_FLAGS="$UV_EXTRA_AUTOMAKE_FLAGS serial-tests"
+fi
+echo "m4_define([UV_EXTRA_AUTOMAKE_FLAGS], [$UV_EXTRA_AUTOMAKE_FLAGS])" \
+    > m4/libuv-extra-automake-flags.m4
+
+(set -x
+"$LIBTOOLIZE" --copy --force
+"$ACLOCAL" -I m4
+)
+if $LIBUV_RELEASE; then
+  "$AUTOCONF" -o /dev/null m4/libuv-check-versions.m4
+  echo "
+AC_PREREQ($autoconf_version)
+AC_INIT([libuv-release-check], [0.0])
+AM_INIT_AUTOMAKE([$automake_version])
+LT_PREREQ($libtoolize_version)
+AC_OUTPUT
+" > m4/libuv-check-versions.m4
+fi
+(
+set -x
+"$AUTOCONF"
+"$AUTOMAKE" --add-missing --copy
+)

deps/uv/cmake-toolchains/cross-mingw32.cmake

@@ -0,0 +1,17 @@
+if(NOT HOST_ARCH)
+  message(SEND_ERROR "-DHOST_ARCH required to be specified")
+endif()
+
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES
+  HOST_ARCH
+  )
+
+SET(CMAKE_SYSTEM_NAME Windows)
+set(COMPILER_PREFIX "${HOST_ARCH}-w64-mingw32")
+find_program(CMAKE_RC_COMPILER NAMES ${COMPILER_PREFIX}-windres)
+find_program(CMAKE_C_COMPILER NAMES ${COMPILER_PREFIX}-gcc)
+find_program(CMAKE_CXX_COMPILER NAMES ${COMPILER_PREFIX}-g++)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

deps/uv/common.gypi

@@ -0,0 +1,213 @@
+{
+  'variables': {
+    'target_arch%': 'ia32',          # set v8's target architecture
+    'host_arch%': 'ia32',            # set v8's host architecture
+    'uv_library%': 'static_library', # allow override to 'shared_library' for DLL/.so builds
+    'msvs_multi_core_compile': '0',  # we do enable multicore compiles, but not using the V8 way
+  },
+
+  'target_defaults': {
+    'default_configuration': 'Debug',
+    'configurations': {
+      'Debug': {
+        'defines': [ 'DEBUG', '_DEBUG' ],
+        'cflags': [ '-g' ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'target_conditions': [
+              ['uv_library=="static_library"', {
+                'RuntimeLibrary': 1, # /MTd static debug
+              }, {
+                'RuntimeLibrary': 3, # /MDd DLL debug
+              }],
+            ],
+            'Optimization': 0, # /Od, no optimization
+            'MinimalRebuild': 'false',
+            'OmitFramePointers': 'false',
+            'BasicRuntimeChecks': 3, # /RTC1
+          },
+          'VCLinkerTool': {
+            'LinkIncremental': 2, # enable incremental linking
+          },
+        },
+        'xcode_settings': {
+          'GCC_OPTIMIZATION_LEVEL': '0',
+        },
+        'conditions': [
+          ['OS != "zos"', {
+            'cflags': [ '-O0', '-fno-common', '-fwrapv' ]
+          }],
+          ['OS == "android"', {
+            'cflags': [ '-fPIE' ],
+            'ldflags': [ '-fPIE', '-pie' ]
+          }]
+        ]
+      },
+      'Release': {
+        'defines': [ 'NDEBUG' ],
+        'cflags': [
+          '-O3',
+        ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'target_conditions': [
+              ['uv_library=="static_library"', {
+                'RuntimeLibrary': 0, # /MT static release
+              }, {
+                'RuntimeLibrary': 2, # /MD DLL release
+              }],
+            ],
+            'Optimization': 3, # /Ox, full optimization
+            'FavorSizeOrSpeed': 1, # /Ot, favour speed over size
+            'InlineFunctionExpansion': 2, # /Ob2, inline anything eligible
+            'WholeProgramOptimization': 'true', # /GL, whole program optimization, needed for LTCG
+            'OmitFramePointers': 'true',
+            'EnableFunctionLevelLinking': 'true',
+            'EnableIntrinsicFunctions': 'true',
+          },
+          'VCLibrarianTool': {
+            'AdditionalOptions': [
+              '/LTCG', # link time code generation
+            ],
+          },
+          'VCLinkerTool': {
+            'LinkTimeCodeGeneration': 1, # link-time code generation
+            'OptimizeReferences': 2, # /OPT:REF
+            'EnableCOMDATFolding': 2, # /OPT:ICF
+            'LinkIncremental': 1, # disable incremental linking
+          },
+        },
+        'conditions': [
+          ['OS != "zos"', {
+            'cflags': [
+              '-fdata-sections',
+              '-ffunction-sections',
+              '-fno-common',
+              '-fomit-frame-pointer',
+            ],
+          }],
+        ]
+      }
+    },
+    'msvs_settings': {
+      'VCCLCompilerTool': {
+        'StringPooling': 'true', # pool string literals
+        'DebugInformationFormat': 3, # Generate a PDB
+        'WarningLevel': 3,
+        'BufferSecurityCheck': 'true',
+        'ExceptionHandling': 1, # /EHsc
+        'SuppressStartupBanner': 'true',
+        'WarnAsError': 'false',
+        'AdditionalOptions': [
+           '/MP', # compile across multiple CPUs
+         ],
+      },
+      'VCLibrarianTool': {
+      },
+      'VCLinkerTool': {
+        'GenerateDebugInformation': 'true',
+        'RandomizedBaseAddress': 2, # enable ASLR
+        'DataExecutionPrevention': 2, # enable DEP
+        'AllowIsolation': 'true',
+        'SuppressStartupBanner': 'true',
+        'target_conditions': [
+          ['_type=="executable"', {
+            'SubSystem': 1, # console executable
+          }],
+        ],
+      },
+    },
+    'conditions': [
+      ['OS == "win"', {
+        'msvs_cygwin_shell': 0, # prevent actions from trying to use cygwin
+        'defines': [
+          'WIN32',
+          # we don't really want VC++ warning us about
+          # how dangerous C functions are...
+          '_CRT_SECURE_NO_DEPRECATE',
+          # ... or that C implementations shouldn't use
+          # POSIX names
+          '_CRT_NONSTDC_NO_DEPRECATE',
+        ],
+        'target_conditions': [
+          ['target_arch=="x64"', {
+            'msvs_configuration_platform': 'x64'
+          }]
+        ]
+      }],
+      ['OS in "freebsd dragonflybsd linux openbsd solaris android aix os400"', {
+        'cflags': [ '-Wall' ],
+        'cflags_cc': [ '-fno-rtti', '-fno-exceptions' ],
+        'target_conditions': [
+          ['_type=="static_library"', {
+            'standalone_static_library': 1, # disable thin archive which needs binutils >= 2.19
+          }],
+        ],
+        'conditions': [
+          [ 'host_arch != target_arch and target_arch=="ia32"', {
+            'cflags': [ '-m32' ],
+            'ldflags': [ '-m32' ],
+          }],
+          [ 'target_arch=="x32"', {
+            'cflags': [ '-mx32' ],
+            'ldflags': [ '-mx32' ],
+          }],
+          [ 'OS=="linux"', {
+            'cflags': [ '-ansi' ],
+          }],
+          [ 'OS=="solaris"', {
+            'cflags': [ '-pthreads' ],
+            'ldflags': [ '-pthreads' ],
+          }],
+          [ 'OS not in "solaris android zos"', {
+            'cflags': [ '-pthread' ],
+            'ldflags': [ '-pthread' ],
+          }],
+          [ 'OS=="aix" and target_arch=="ppc64"', {
+            'cflags': [ '-maix64' ],
+            'ldflags': [ '-maix64' ],
+          }],
+        ],
+      }],
+      ['OS=="mac"', {
+        'xcode_settings': {
+          'ALWAYS_SEARCH_USER_PATHS': 'NO',
+          'GCC_CW_ASM_SYNTAX': 'NO',                # No -fasm-blocks
+          'GCC_DYNAMIC_NO_PIC': 'NO',               # No -mdynamic-no-pic
+                                                    # (Equivalent to -fPIC)
+          'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',        # -fno-exceptions
+          'GCC_ENABLE_CPP_RTTI': 'NO',              # -fno-rtti
+          'GCC_ENABLE_PASCAL_STRINGS': 'NO',        # No -mpascal-strings
+          'GCC_THREADSAFE_STATICS': 'NO',           # -fno-threadsafe-statics
+          'PREBINDING': 'NO',                       # No -Wl,-prebind
+          'USE_HEADERMAP': 'NO',
+          'WARNING_CFLAGS': [
+            '-Wall',
+            '-Wendif-labels',
+            '-W',
+            '-Wno-unused-parameter',
+            '-Wstrict-prototypes',
+          ],
+        },
+        'conditions': [
+          ['target_arch=="ia32"', {
+            'xcode_settings': {'ARCHS': ['i386']},
+          }],
+          ['target_arch=="x64"', {
+            'xcode_settings': {'ARCHS': ['x86_64']},
+          }],
+        ],
+        'target_conditions': [
+          ['_type!="static_library"', {
+            'xcode_settings': {'OTHER_LDFLAGS': ['-Wl,-search_paths_first']},
+          }],
+        ],
+      }],
+     ['OS=="solaris"', {
+       'cflags': [ '-fno-omit-frame-pointer' ],
+       # pull in V8's postmortem metadata
+       'ldflags': [ '-Wl,-z,allextract' ]
+     }],
+    ],
+  },
+}

deps/uv/configure.ac

@@ -0,0 +1,92 @@
+# Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+AC_PREREQ(2.57)
+AC_INIT([libuv], [1.51.0], [https://github.com/libuv/libuv/issues])
+AC_CONFIG_MACRO_DIR([m4])
+m4_include([m4/libuv-extra-automake-flags.m4])
+m4_include([m4/as_case.m4])
+m4_include([m4/libuv-check-flags.m4])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects] UV_EXTRA_AUTOMAKE_FLAGS)
+AM_MAINTAINER_MODE([enable]) # pass --disable-maintainer-mode if autotools may be unavailable
+AC_CANONICAL_HOST
+AC_ENABLE_SHARED
+AC_ENABLE_STATIC
+AC_PROG_CC
+AM_PROG_CC_C_O
+
+CC_ATTRIBUTE_VISIBILITY([default], [
+  CC_FLAG_VISIBILITY([CFLAGS="${CFLAGS} -fvisibility=hidden"])
+])
+# Xlc has a flag "-f<filename>". Need to use CC_CHECK_FLAG_SUPPORTED_APPEND so
+# we exclude -fno-strict-aliasing for xlc
+CC_CHECK_FLAG_SUPPORTED_APPEND([-fno-strict-aliasing])
+CC_CHECK_CFLAGS_APPEND([-g])
+CC_CHECK_CFLAGS_APPEND([-std=gnu11])
+CC_CHECK_CFLAGS_APPEND([-Wall])
+CC_CHECK_CFLAGS_APPEND([-Wextra])
+CC_CHECK_CFLAGS_APPEND([-Wno-long-long])
+CC_CHECK_CFLAGS_APPEND([-Wno-unused-parameter])
+CC_CHECK_CFLAGS_APPEND([-Wstrict-prototypes])
+# AM_PROG_AR is not available in automake v0.11 but it's essential in v0.12.
+m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
+# autoconf complains if AC_PROG_LIBTOOL precedes AM_PROG_AR.
+AC_PROG_LIBTOOL
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+LT_INIT
+AX_PTHREAD([
+    LIBS="$LIBS $PTHREAD_LIBS"
+    CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+])
+AC_SEARCH_LIBS([dlopen], [dl])
+AC_SEARCH_LIBS([kstat_lookup], [kstat])
+AC_SEARCH_LIBS([gethostbyname], [nsl])
+AC_SEARCH_LIBS([perfstat_cpu], [perfstat])
+AC_SEARCH_LIBS([clock_gettime], [rt])
+AC_SEARCH_LIBS([sendfile], [sendfile])
+AC_SEARCH_LIBS([socket], [socket])
+AC_SYS_LARGEFILE
+AM_CONDITIONAL([AIX],      [AS_CASE([$host_os],[aix*],          [true], [false])])
+AM_CONDITIONAL([ANDROID],  [AS_CASE([$host_os],[linux-android*],[true], [false])])
+AM_CONDITIONAL([CYGWIN],   [AS_CASE([$host_os],[cygwin*],       [true], [false])])
+AM_CONDITIONAL([DARWIN],   [AS_CASE([$host_os],[darwin*],       [true], [false])])
+AM_CONDITIONAL([DRAGONFLY],[AS_CASE([$host_os],[dragonfly*],    [true], [false])])
+AM_CONDITIONAL([FREEBSD],  [AS_CASE([$host_os],[freebsd*],      [true], [false])])
+AM_CONDITIONAL([HAIKU],    [AS_CASE([$host_os],[haiku],         [true], [false])])
+AM_CONDITIONAL([HURD],     [AS_CASE([$host_os],[gnu*],          [true], [false])])
+AM_CONDITIONAL([LINUX],    [AS_CASE([$host_os],[linux*],        [true], [false])])
+AM_CONDITIONAL([MSYS],     [AS_CASE([$host_os],[msys*],         [true], [false])])
+AM_CONDITIONAL([NETBSD],   [AS_CASE([$host_os],[netbsd*],       [true], [false])])
+AM_CONDITIONAL([OPENBSD],  [AS_CASE([$host_os],[openbsd*],      [true], [false])])
+AM_CONDITIONAL([OS390],    [AS_CASE([$host_os],[openedition*],  [true], [false])])
+AM_CONDITIONAL([OS400],    [AS_CASE([$host_os],[os400],         [true], [false])])
+AM_CONDITIONAL([SUNOS],    [AS_CASE([$host_os],[solaris*],      [true], [false])])
+AM_CONDITIONAL([WINNT],    [AS_CASE([$host_os],[mingw*],        [true], [false])])
+AS_CASE([$host_os],[mingw*], [
+    LIBS="$LIBS -lws2_32 -lpsapi -liphlpapi -luserenv -luser32 -ldbghelp -lole32 -lshell32"
+])
+AS_CASE([$host_os], [solaris2.10], [
+    CFLAGS="$CFLAGS -DSUNOS_NO_IFADDRS"
+])
+AS_CASE([$host_os], [netbsd*], [AC_CHECK_LIB([kvm], [kvm_open])])
+AS_CASE([$host_os], [haiku], [
+    LIBS="$LIBS -lnetwork"
+])
+AC_CHECK_HEADERS([sys/ahafs_evProds.h])
+AC_CONFIG_FILES([Makefile libuv.pc])
+AC_CONFIG_LINKS([test/fixtures/empty_file:test/fixtures/empty_file])
+AC_CONFIG_LINKS([test/fixtures/load_error.node:test/fixtures/load_error.node])
+AC_CONFIG_LINKS([test/fixtures/lorem_ipsum.txt:test/fixtures/lorem_ipsum.txt])
+AC_CONFIG_LINKS([test/fixtures/one_file/one_file:test/fixtures/one_file/one_file])
+AC_OUTPUT

deps/uv/docs/make.bat

@@ -0,0 +1,243 @@
+@ECHO OFF
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set BUILDDIR=build
+set SRCDIR=src
+set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% %SRCDIR%
+set I18NSPHINXOPTS=%SPHINXOPTS% %SRCDIR%
+if NOT "%PAPER%" == "" (
+	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
+	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
+)
+
+if "%1" == "" goto help
+
+if "%1" == "help" (
+	:help
+	echo.Please use `make ^<target^>` where ^<target^> is one of
+	echo.  html       to make standalone HTML files
+	echo.  dirhtml    to make HTML files named index.html in directories
+	echo.  singlehtml to make a single large HTML file
+	echo.  pickle     to make pickle files
+	echo.  json       to make JSON files
+	echo.  htmlhelp   to make HTML files and a HTML help project
+	echo.  qthelp     to make HTML files and a qthelp project
+	echo.  devhelp    to make HTML files and a Devhelp project
+	echo.  epub       to make an epub
+	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
+	echo.  text       to make text files
+	echo.  man        to make manual pages
+	echo.  texinfo    to make Texinfo files
+	echo.  gettext    to make PO message catalogs
+	echo.  changes    to make an overview over all changed/added/deprecated items
+	echo.  xml        to make Docutils-native XML files
+	echo.  pseudoxml  to make pseudoxml-XML files for display purposes
+	echo.  linkcheck  to check all external links for integrity
+	echo.  doctest    to run all doctests embedded in the documentation if enabled
+	goto end
+)
+
+if "%1" == "clean" (
+	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
+	del /q /s %BUILDDIR%\*
+	goto end
+)
+
+
+%SPHINXBUILD% 2> nul
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "html" (
+	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
+	goto end
+)
+
+if "%1" == "dirhtml" (
+	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
+	goto end
+)
+
+if "%1" == "singlehtml" (
+	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
+	goto end
+)
+
+if "%1" == "pickle" (
+	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the pickle files.
+	goto end
+)
+
+if "%1" == "json" (
+	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can process the JSON files.
+	goto end
+)
+
+if "%1" == "htmlhelp" (
+	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run HTML Help Workshop with the ^
+.hhp project file in %BUILDDIR%/htmlhelp.
+	goto end
+)
+
+if "%1" == "qthelp" (
+	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; now you can run "qcollectiongenerator" with the ^
+.qhcp project file in %BUILDDIR%/qthelp, like this:
+	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\libuv.qhcp
+	echo.To view the help file:
+	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\libuv.ghc
+	goto end
+)
+
+if "%1" == "devhelp" (
+	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished.
+	goto end
+)
+
+if "%1" == "epub" (
+	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The epub file is in %BUILDDIR%/epub.
+	goto end
+)
+
+if "%1" == "latex" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "latexpdf" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	cd %BUILDDIR%/latex
+	make all-pdf
+	cd %BUILDDIR%/..
+	echo.
+	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "latexpdfja" (
+	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
+	cd %BUILDDIR%/latex
+	make all-pdf-ja
+	cd %BUILDDIR%/..
+	echo.
+	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
+	goto end
+)
+
+if "%1" == "text" (
+	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The text files are in %BUILDDIR%/text.
+	goto end
+)
+
+if "%1" == "man" (
+	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The manual pages are in %BUILDDIR%/man.
+	goto end
+)
+
+if "%1" == "texinfo" (
+	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
+	goto end
+)
+
+if "%1" == "gettext" (
+	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
+	goto end
+)
+
+if "%1" == "changes" (
+	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.The overview file is in %BUILDDIR%/changes.
+	goto end
+)
+
+if "%1" == "linkcheck" (
+	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Link check complete; look for any errors in the above output ^
+or in %BUILDDIR%/linkcheck/output.txt.
+	goto end
+)
+
+if "%1" == "doctest" (
+	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Testing of doctests in the sources finished, look at the ^
+results in %BUILDDIR%/doctest/output.txt.
+	goto end
+)
+
+if "%1" == "xml" (
+	%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The XML files are in %BUILDDIR%/xml.
+	goto end
+)
+
+if "%1" == "pseudoxml" (
+	%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml
+	if errorlevel 1 exit /b 1
+	echo.
+	echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.
+	goto end
+)
+
+:end

deps/uv/docs/requirements.txt

@@ -0,0 +1,36 @@
+# primary
+furo==2023.5.20
+Sphinx==6.1.3
+
+# dependencies
+alabaster==0.7.13
+Babel==2.11.0
+beautifulsoup4==4.12.2
+certifi==2022.12.7
+charset-normalizer==3.0.1
+colorama==0.4.6
+docutils==0.19
+idna==3.4
+imagesize==1.4.1
+importlib-metadata==6.0.0
+Jinja2==3.1.2
+livereload==2.6.3
+MarkupSafe==2.1.2
+packaging==23.0
+Pygments==2.14.0
+pytz==2022.7.1
+requests==2.28.2
+six==1.16.0
+snowballstemmer==2.2.0
+soupsieve==2.4.1
+sphinx-autobuild==2021.3.14
+sphinx-basic-ng==1.0.0b2
+sphinxcontrib-devhelp==1.0.2
+sphinxcontrib-htmlhelp==2.0.0
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.3
+sphinxcontrib-serializinghtml==1.1.5
+sphinxcontrib.applehelp==1.0.3
+tornado==6.3.2
+urllib3==1.26.14
+zipp==3.11.0

deps/uv/docs/src/api.rst

@@ -0,0 +1,36 @@
+.. _api:
+
+API documentation
+=================
+
+.. toctree::
+   :maxdepth: 1
+
+   errors
+   version
+   loop
+   handle
+   request
+   timer
+   prepare
+   check
+   idle
+   async
+   poll
+   signal
+   process
+   stream
+   tcp
+   pipe
+   tty
+   udp
+   fs_event
+   fs_poll
+   fs
+   threadpool
+   dns
+   dll
+   threading
+   misc
+   metrics
+

deps/uv/docs/src/async.rst

@@ -0,0 +1,65 @@
+
+.. _async:
+
+:c:type:`uv_async_t` --- Async handle
+=====================================
+
+Async handles allow the user to "wakeup" the event loop and get a callback
+called from another thread.
+
+
+Data types
+----------
+
+.. c:type:: uv_async_t
+
+    Async handle type.
+
+.. c:type:: void (*uv_async_cb)(uv_async_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_async_init`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_async_init(uv_loop_t* loop, uv_async_t* async, uv_async_cb async_cb)
+
+    Initialize the handle. A NULL callback is allowed.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. note::
+        Unlike other handle initialization  functions, it immediately starts the handle.
+
+.. c:function:: int uv_async_send(uv_async_t* async)
+
+    Wake up the event loop and call the async handle's callback.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. note::
+        It's safe to call this function from any thread. The callback will be called on the
+        loop thread.
+
+    .. note::
+        :c:func:`uv_async_send` is `async-signal-safe <https://man7.org/linux/man-pages/man7/signal-safety.7.html>`_.
+        It's safe to call this function from a signal handler.
+
+    .. warning::
+        libuv will coalesce calls to :c:func:`uv_async_send`, that is, not every call to it will
+        yield an execution of the callback. For example: if :c:func:`uv_async_send` is called 5
+        times in a row before the callback is called, the callback will only be called once. If
+        :c:func:`uv_async_send` is called again after the callback was called, it will be called
+        again.
+
+.. seealso::
+    The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/check.rst

@@ -0,0 +1,54 @@
+
+.. _check:
+
+:c:type:`uv_check_t` --- Check handle
+=====================================
+
+Check handles will run the given callback once per loop iteration, right
+after polling for i/o.
+
+
+Data types
+----------
+
+.. c:type:: uv_check_t
+
+    Check handle type.
+
+.. c:type:: void (*uv_check_cb)(uv_check_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_check_start`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_check_init(uv_loop_t* loop, uv_check_t* check)
+
+    Initialize the handle. This function always succeeds.
+
+    :returns: 0
+
+.. c:function:: int uv_check_start(uv_check_t* check, uv_check_cb cb)
+
+    Start the handle with the given callback. This function always succeeds,
+    except when `cb` is `NULL`.
+
+    :returns: 0 on success, or `UV_EINVAL` when `cb == NULL`.
+
+.. c:function:: int uv_check_stop(uv_check_t* check)
+
+    Stop the handle, the callback will no longer be called.
+    This function always succeeds.
+
+    :returns: 0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/conf.py

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*-
+#
+# libuv documentation documentation build configuration file, created by
+# sphinx-quickstart on Sun Jul 27 11:47:51 2014.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import os
+import re
+import sys
+
+
+def get_libuv_version():
+    with open('../../include/uv/version.h') as f:
+        data = f.read()
+    try:
+        m = re.search(r"""^#define UV_VERSION_MAJOR (\d+)$""", data, re.MULTILINE)
+        major = int(m.group(1))
+        m = re.search(r"""^#define UV_VERSION_MINOR (\d+)$""", data, re.MULTILINE)
+        minor = int(m.group(1))
+        m = re.search(r"""^#define UV_VERSION_PATCH (\d+)$""", data, re.MULTILINE)
+        patch = int(m.group(1))
+        m = re.search(r"""^#define UV_VERSION_IS_RELEASE (\d)$""", data, re.MULTILINE)
+        is_release = int(m.group(1))
+        m = re.search(r"""^#define UV_VERSION_SUFFIX \"(\w*)\"$""", data, re.MULTILINE)
+        suffix = m.group(1)
+        return '%d.%d.%d%s' % (major, minor, patch, '-%s' % suffix if not is_release else '')
+    except Exception:
+        return 'unknown'
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+sys.path.insert(0, os.path.abspath('sphinx-plugins'))
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['manpage']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'libuv API documentation'
+copyright = u'2014-present, libuv contributors'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = get_libuv_version()
+# The full version, including alpha/beta/rc tags.
+release = version
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = []
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+#keep_warnings = False
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'furo'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+html_title = 'libuv documentation'
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+html_short_title = 'libuv %s documentation' % version
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+html_logo = 'static/logo.png'
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+html_favicon = 'static/favicon.ico'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['static']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#html_extra_path = []
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'libuv'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+  ('index', 'libuv.tex', u'libuv documentation',
+   u'libuv contributors', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ('index', 'libuv', u'libuv documentation',
+     [u'libuv contributors'], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  ('index', 'libuv', u'libuv documentation',
+   u'libuv contributors', 'libuv', 'Cross-platform asynchronous I/O',
+   'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#texinfo_no_detailmenu = False
+
+
+# -- Options for Epub output ----------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = u'libuv documentation'
+epub_author = u'libuv contributors'
+epub_publisher = u'libuv contributors'
+epub_copyright = u'2014-present, libuv contributors'
+
+# The basename for the epub file. It defaults to the project name.
+epub_basename = u'libuv'
+
+# The HTML theme for the epub output. Since the default themes are not optimized
+# for small screen space, using the same theme for HTML and epub output is
+# usually not wise. This defaults to 'epub', a theme designed to save visual
+# space.
+#epub_theme = 'epub'
+
+# The language of the text. It defaults to the language option
+# or en if the language is not set.
+#epub_language = ''
+
+# The scheme of the identifier. Typical schemes are ISBN or URL.
+#epub_scheme = ''
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#epub_identifier = ''
+
+# A unique identification for the text.
+#epub_uid = ''
+
+# A tuple containing the cover image and cover page html template filenames.
+#epub_cover = ()
+
+# A sequence of (type, uri, title) tuples for the guide element of content.opf.
+#epub_guide = ()
+
+# HTML files that should be inserted before the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#epub_pre_files = []
+
+# HTML files shat should be inserted after the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#epub_post_files = []
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+# The depth of the table of contents in toc.ncx.
+#epub_tocdepth = 3
+
+# Allow duplicate toc entries.
+#epub_tocdup = True
+
+# Choose between 'default' and 'includehidden'.
+#epub_tocscope = 'default'
+
+# Fix unsupported image types using the PIL.
+#epub_fix_images = False
+
+# Scale large images.
+#epub_max_image_width = 0
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#epub_show_urls = 'inline'
+
+# If false, no index is generated.
+#epub_use_index = True

deps/uv/docs/src/design.rst

@@ -0,0 +1,141 @@
+
+.. _design:
+
+Design overview
+===============
+
+libuv is cross-platform support library which was originally written for `Node.js`_. It's designed
+around the event-driven asynchronous I/O model.
+
+.. _Node.js: https://nodejs.org
+
+The library provides much more than a simple abstraction over different I/O polling mechanisms:
+'handles' and 'streams' provide a high level abstraction for sockets and other entities;
+cross-platform file I/O and threading functionality is also provided, amongst other things.
+
+Here is a diagram illustrating the different parts that compose libuv and what subsystem they
+relate to:
+
+.. image:: static/architecture.png
+    :scale: 75%
+    :align: center
+
+
+Handles and requests
+^^^^^^^^^^^^^^^^^^^^
+
+libuv provides users with 2 abstractions to work with, in combination with the event loop:
+handles and requests.
+
+Handles represent long-lived objects capable of performing certain operations while active. Some examples:
+
+- A prepare handle gets its callback called once every loop iteration when active.
+- A TCP server handle that gets its connection callback called every time there is a new connection.
+
+Requests represent (typically) short-lived operations. These operations can be performed over a
+handle: write requests are used to write data on a handle; or standalone: getaddrinfo requests
+don't need a handle they run directly on the loop.
+
+
+The I/O loop
+^^^^^^^^^^^^
+
+The I/O (or event) loop is the central part of libuv. It establishes the content for all I/O
+operations, and it's meant to be tied to a single thread. One can run multiple event loops
+as long as each runs in a different thread. The libuv event loop (or any other API involving
+the loop or handles, for that matter) **is not thread-safe** except where stated otherwise.
+
+The event loop follows the rather usual single threaded asynchronous I/O approach: all (network)
+I/O is performed on non-blocking sockets which are polled using the best mechanism available
+on the given platform: epoll on Linux, kqueue on OSX and other BSDs, event ports on SunOS and IOCP
+on Windows. As part of a loop iteration the loop will block waiting for I/O activity on sockets
+which have been added to the poller and callbacks will be fired indicating socket conditions
+(readable, writable hangup) so handles can read, write or perform the desired I/O operation.
+
+In order to better understand how the event loop operates, the following diagram illustrates all
+stages of a loop iteration:
+
+.. image:: static/loop_iteration.png
+    :scale: 75%
+    :align: center
+
+
+#. The loop concept of 'now' is initially set.
+
+#. Due timers are run if the loop was run with ``UV_RUN_DEFAULT``. All active timers scheduled
+   for a time before the loop's concept of *now* get their callbacks called.
+
+#. If the loop is *alive*  an iteration is started, otherwise the loop will exit immediately. So,
+   when is a loop considered to be *alive*? If a loop has active and ref'd handles, active
+   requests or closing handles it's considered to be *alive*.
+
+#. Pending callbacks are called. All I/O callbacks are called right after polling for I/O, for the
+   most part. There are cases, however, in which calling such a callback is deferred for the next
+   loop iteration. If the previous iteration deferred any I/O callback it will be run at this point.
+
+#. Idle handle callbacks are called. Despite the unfortunate name, idle handles are run on every
+   loop iteration, if they are active.
+
+#. Prepare handle callbacks are called. Prepare handles get their callbacks called right before
+   the loop will block for I/O.
+
+#. Poll timeout is calculated. Before blocking for I/O the loop calculates for how long it should
+   block. These are the rules when calculating the timeout:
+
+        * If the loop was run with the ``UV_RUN_NOWAIT`` flag, the timeout is 0.
+        * If the loop is going to be stopped (:c:func:`uv_stop` was called), the timeout is 0.
+        * If there are no active handles or requests, the timeout is 0.
+        * If there are any idle handles active, the timeout is 0.
+        * If there are any handles pending to be closed, the timeout is 0.
+        * If none of the above cases matches, the timeout of the closest timer is taken, or
+          if there are no active timers, infinity.
+
+#. The loop blocks for I/O. At this point the loop will block for I/O for the duration calculated
+   in the previous step. All I/O related handles that were monitoring a given file descriptor
+   for a read or write operation get their callbacks called at this point.
+
+#. Check handle callbacks are called. Check handles get their callbacks called right after the
+   loop has blocked for I/O. Check handles are essentially the counterpart of prepare handles.
+
+#. Close callbacks are called. If a handle was closed by calling :c:func:`uv_close` it will
+   get the close callback called.
+
+#. The loop concept of 'now' is updated.
+
+#. Due timers are run. Note that 'now' is not updated again until the next loop iteration.
+   So if a timer became due while other timers were being processed, it won't be run until
+   the following event loop iteration.
+
+#. Iteration ends. If the loop was run with ``UV_RUN_NOWAIT`` or ``UV_RUN_ONCE`` modes the
+   iteration ends and :c:func:`uv_run` will return. If the loop was run with ``UV_RUN_DEFAULT``
+   it will continue from the start if it's still *alive*, otherwise it will also end.
+
+
+.. important::
+    libuv uses a thread pool to make asynchronous file I/O operations possible, but
+    network I/O is **always** performed in a single thread, each loop's thread.
+
+.. note::
+    While the polling mechanism is different, libuv makes the execution model consistent
+    across Unix systems and Windows.
+
+
+File I/O
+^^^^^^^^
+
+Unlike network I/O, there are no platform-specific file I/O primitives libuv could rely on,
+so the current approach is to run blocking file I/O operations in a thread pool.
+
+For a thorough explanation of the cross-platform file I/O landscape, check out
+`this post <https://blog.libtorrent.org/2012/10/asynchronous-disk-io/>`_.
+
+libuv currently uses a global thread pool on which all loops can queue work. 3 types of
+operations are currently run on this pool:
+
+    * File system operations
+    * DNS functions (getaddrinfo and getnameinfo)
+    * User specified code via :c:func:`uv_queue_work`
+
+.. warning::
+    See the :c:ref:`threadpool` section for more details, but keep in mind the thread pool size
+    is quite limited.

deps/uv/docs/src/dll.rst

@@ -0,0 +1,44 @@
+
+.. _dll:
+
+Shared library handling
+=======================
+
+libuv provides cross platform utilities for loading shared libraries and
+retrieving symbols from them, using the following API.
+
+
+Data types
+----------
+
+.. c:type:: uv_lib_t
+
+    Shared library data type.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+
+API
+---
+
+.. c:function:: int uv_dlopen(const char* filename, uv_lib_t* lib)
+
+    Opens a shared library. The filename is in utf-8. Returns 0 on success and
+    -1 on error. Call :c:func:`uv_dlerror` to get the error message.
+
+.. c:function:: void uv_dlclose(uv_lib_t* lib)
+
+    Close the shared library.
+
+.. c:function:: int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr)
+
+    Retrieves a data pointer from a dynamic library. It is legal for a symbol
+    to map to NULL. Returns 0 on success and -1 if the symbol was not found.
+
+.. c:function:: const char* uv_dlerror(const uv_lib_t* lib)
+
+    Returns the last uv_dlopen() or uv_dlsym() error message.

deps/uv/docs/src/dns.rst

@@ -0,0 +1,108 @@
+
+.. _dns:
+
+DNS utility functions
+=====================
+
+libuv provides asynchronous variants of `getaddrinfo` and `getnameinfo`.
+
+
+Data types
+----------
+
+.. c:type:: uv_getaddrinfo_t
+
+    `getaddrinfo` request type.
+
+.. c:type:: void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req, int status, struct addrinfo* res)
+
+    Callback which will be called with the getaddrinfo request result once
+    complete. In case it was cancelled, `status` will have a value of
+    ``UV_ECANCELED``.
+
+.. c:type:: uv_getnameinfo_t
+
+    `getnameinfo` request type.
+
+.. c:type:: void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req, int status, const char* hostname, const char* service)
+
+    Callback which will be called with the getnameinfo request result once
+    complete. In case it was cancelled, `status` will have a value of
+    ``UV_ECANCELED``.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: uv_loop_t* uv_getaddrinfo_t.loop
+
+    Loop that started this getaddrinfo request and where completion will be
+    reported. Readonly.
+
+.. c:member:: struct addrinfo* uv_getaddrinfo_t.addrinfo
+
+    Pointer to a `struct addrinfo` containing the result. Must be freed by the user
+    with :c:func:`uv_freeaddrinfo`.
+
+    .. versionchanged:: 1.3.0 the field is declared as public.
+
+.. c:member:: uv_loop_t* uv_getnameinfo_t.loop
+
+    Loop that started this getnameinfo request and where completion will be
+    reported. Readonly.
+
+.. c:member:: char[NI_MAXHOST] uv_getnameinfo_t.host
+
+    Char array containing the resulting host. It's null terminated.
+
+    .. versionchanged:: 1.3.0 the field is declared as public.
+
+.. c:member:: char[NI_MAXSERV] uv_getnameinfo_t.service
+
+    Char array containing the resulting service. It's null terminated.
+
+    .. versionchanged:: 1.3.0 the field is declared as public.
+
+.. seealso:: The :c:type:`uv_req_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_getaddrinfo(uv_loop_t* loop, uv_getaddrinfo_t* req, uv_getaddrinfo_cb getaddrinfo_cb, const char* node, const char* service, const struct addrinfo* hints)
+
+    Asynchronous :man:`getaddrinfo(3)`.
+
+    Either node or service may be NULL but not both.
+
+    `hints` is a pointer to a struct addrinfo with additional address type
+    constraints, or NULL. Consult `man -s 3 getaddrinfo` for more details.
+
+    Returns 0 on success or an error code < 0 on failure. If successful, the
+    callback will get called sometime in the future with the lookup result,
+    which is either:
+
+    * status == 0, the res argument points to a valid `struct addrinfo`, or
+    * status < 0, the res argument is NULL. See the UV_EAI_* constants.
+
+    Call :c:func:`uv_freeaddrinfo` to free the addrinfo structure.
+
+    .. versionchanged:: 1.3.0 the callback parameter is now allowed to be NULL,
+                        in which case the request will run **synchronously**.
+
+.. c:function:: void uv_freeaddrinfo(struct addrinfo* ai)
+
+    Free the struct addrinfo. Passing NULL is allowed and is a no-op.
+
+.. c:function:: int uv_getnameinfo(uv_loop_t* loop, uv_getnameinfo_t* req, uv_getnameinfo_cb getnameinfo_cb, const struct sockaddr* addr, int flags)
+
+    Asynchronous :man:`getnameinfo(3)`.
+
+    Returns 0 on success or an error code < 0 on failure. If successful, the
+    callback will get called sometime in the future with the lookup result.
+    Consult `man -s 3 getnameinfo` for more details.
+
+    .. versionchanged:: 1.3.0 the callback parameter is now allowed to be NULL,
+                        in which case the request will run **synchronously**.
+
+.. seealso:: The :c:type:`uv_req_t` API functions also apply.

deps/uv/docs/src/errors.rst

@@ -0,0 +1,388 @@
+
+.. _errors:
+
+Error handling
+==============
+
+In libuv errors are negative numbered constants. As a rule of thumb, whenever
+there is a status parameter, or an API functions returns an integer, a negative
+number will imply an error.
+
+When a function which takes a callback returns an error, the callback will never
+be called.
+
+.. note::
+    Implementation detail: on Unix error codes are the negated `errno` (or `-errno`), while on
+    Windows they are defined by libuv to arbitrary negative numbers.
+
+
+Error constants
+---------------
+
+.. c:macro:: UV_E2BIG
+
+    argument list too long
+
+.. c:macro:: UV_EACCES
+
+    permission denied
+
+.. c:macro:: UV_EADDRINUSE
+
+    address already in use
+
+.. c:macro:: UV_EADDRNOTAVAIL
+
+    address not available
+
+.. c:macro:: UV_EAFNOSUPPORT
+
+    address family not supported
+
+.. c:macro:: UV_EAGAIN
+
+    resource temporarily unavailable
+
+.. c:macro:: UV_EAI_ADDRFAMILY
+
+    address family not supported
+
+.. c:macro:: UV_EAI_AGAIN
+
+    temporary failure
+
+.. c:macro:: UV_EAI_BADFLAGS
+
+    bad ai_flags value
+
+.. c:macro:: UV_EAI_BADHINTS
+
+    invalid value for hints
+
+.. c:macro:: UV_EAI_CANCELED
+
+    request canceled
+
+.. c:macro:: UV_EAI_FAIL
+
+    permanent failure
+
+.. c:macro:: UV_EAI_FAMILY
+
+    ai_family not supported
+
+.. c:macro:: UV_EAI_MEMORY
+
+    out of memory
+
+.. c:macro:: UV_EAI_NODATA
+
+    no address
+
+.. c:macro:: UV_EAI_NONAME
+
+    unknown node or service
+
+.. c:macro:: UV_EAI_OVERFLOW
+
+    argument buffer overflow
+
+.. c:macro:: UV_EAI_PROTOCOL
+
+    resolved protocol is unknown
+
+.. c:macro:: UV_EAI_SERVICE
+
+    service not available for socket type
+
+.. c:macro:: UV_EAI_SOCKTYPE
+
+    socket type not supported
+
+.. c:macro:: UV_EALREADY
+
+    connection already in progress
+
+.. c:macro:: UV_EBADF
+
+    bad file descriptor
+
+.. c:macro:: UV_EBUSY
+
+    resource busy or locked
+
+.. c:macro:: UV_ECANCELED
+
+    operation canceled
+
+.. c:macro:: UV_ECHARSET
+
+    invalid Unicode character
+
+.. c:macro:: UV_ECONNABORTED
+
+    software caused connection abort
+
+.. c:macro:: UV_ECONNREFUSED
+
+    connection refused
+
+.. c:macro:: UV_ECONNRESET
+
+    connection reset by peer
+
+.. c:macro:: UV_EDESTADDRREQ
+
+    destination address required
+
+.. c:macro:: UV_EEXIST
+
+    file already exists
+
+.. c:macro:: UV_EFAULT
+
+    bad address in system call argument
+
+.. c:macro:: UV_EFBIG
+
+    file too large
+
+.. c:macro:: UV_EHOSTUNREACH
+
+    host is unreachable
+
+.. c:macro:: UV_EINTR
+
+    interrupted system call
+
+.. c:macro:: UV_EINVAL
+
+    invalid argument
+
+.. c:macro:: UV_EIO
+
+    i/o error
+
+.. c:macro:: UV_EISCONN
+
+    socket is already connected
+
+.. c:macro:: UV_EISDIR
+
+    illegal operation on a directory
+
+.. c:macro:: UV_ELOOP
+
+    too many symbolic links encountered
+
+.. c:macro:: UV_EMFILE
+
+    too many open files
+
+.. c:macro:: UV_EMSGSIZE
+
+    message too long
+
+.. c:macro:: UV_ENAMETOOLONG
+
+    name too long
+
+.. c:macro:: UV_ENETDOWN
+
+    network is down
+
+.. c:macro:: UV_ENETUNREACH
+
+    network is unreachable
+
+.. c:macro:: UV_ENFILE
+
+    file table overflow
+
+.. c:macro:: UV_ENOBUFS
+
+    no buffer space available
+
+.. c:macro:: UV_ENODEV
+
+    no such device
+
+.. c:macro:: UV_ENOENT
+
+    no such file or directory
+
+.. c:macro:: UV_ENOMEM
+
+    not enough memory
+
+.. c:macro:: UV_ENONET
+
+    machine is not on the network
+
+.. c:macro:: UV_ENOPROTOOPT
+
+    protocol not available
+
+.. c:macro:: UV_ENOSPC
+
+    no space left on device
+
+.. c:macro:: UV_ENOSYS
+
+    function not implemented
+
+.. c:macro:: UV_ENOTCONN
+
+    socket is not connected
+
+.. c:macro:: UV_ENOTDIR
+
+    not a directory
+
+.. c:macro:: UV_ENOTEMPTY
+
+    directory not empty
+
+.. c:macro:: UV_ENOTSOCK
+
+    socket operation on non-socket
+
+.. c:macro:: UV_ENOTSUP
+
+    operation not supported on socket
+
+.. c:macro:: UV_EOVERFLOW
+
+    value too large for defined data type
+
+.. c:macro:: UV_EPERM
+
+    operation not permitted
+
+.. c:macro:: UV_EPIPE
+
+    broken pipe
+
+.. c:macro:: UV_EPROTO
+
+    protocol error
+
+.. c:macro:: UV_EPROTONOSUPPORT
+
+    protocol not supported
+
+.. c:macro:: UV_EPROTOTYPE
+
+    protocol wrong type for socket
+
+.. c:macro:: UV_ERANGE
+
+    result too large
+
+.. c:macro:: UV_EROFS
+
+    read-only file system
+
+.. c:macro:: UV_ESHUTDOWN
+
+    cannot send after transport endpoint shutdown
+
+.. c:macro:: UV_ESPIPE
+
+    invalid seek
+
+.. c:macro:: UV_ESRCH
+
+    no such process
+
+.. c:macro:: UV_ETIMEDOUT
+
+    connection timed out
+
+.. c:macro:: UV_ETXTBSY
+
+    text file is busy
+
+.. c:macro:: UV_EXDEV
+
+    cross-device link not permitted
+
+.. c:macro:: UV_UNKNOWN
+
+    unknown error
+
+.. c:macro:: UV_EOF
+
+    end of file
+
+.. c:macro:: UV_ENXIO
+
+    no such device or address
+
+.. c:macro:: UV_EMLINK
+
+    too many links
+
+.. c:macro:: UV_ENOTTY
+
+    inappropriate ioctl for device
+
+.. c:macro:: UV_EFTYPE
+
+    inappropriate file type or format
+
+.. c:macro:: UV_EILSEQ
+
+    illegal byte sequence
+
+.. c:macro:: UV_ESOCKTNOSUPPORT
+
+    socket type not supported
+
+.. c:macro:: UV_EUNATCH
+
+    protocol driver not attached
+
+API
+---
+
+.. c:macro:: UV_ERRNO_MAP(iter_macro)
+
+    Macro that expands to a series of invocations of `iter_macro` for
+    each of the error constants above. `iter_macro` is invoked with two
+    arguments: the name of the error constant without the `UV_` prefix,
+    and the error message string literal.
+
+.. c:function:: const char* uv_strerror(int err)
+
+    Returns the error message for the given error code.  Leaks a few bytes
+    of memory when you call it with an unknown error code.
+
+.. c:function:: char* uv_strerror_r(int err, char* buf, size_t buflen)
+
+    Returns the error message for the given error code. The zero-terminated
+    message is stored in the user-supplied buffer `buf` of at most `buflen` bytes.
+
+    .. versionadded:: 1.22.0
+
+.. c:function:: const char* uv_err_name(int err)
+
+    Returns the error name for the given error code.  Leaks a few bytes
+    of memory when you call it with an unknown error code.
+
+.. c:function:: char* uv_err_name_r(int err, char* buf, size_t buflen)
+
+    Returns the error name for the given error code. The zero-terminated
+    name is stored in the user-supplied buffer `buf` of at most `buflen` bytes.
+
+    .. versionadded:: 1.22.0
+
+.. c:function:: int uv_translate_sys_error(int sys_errno)
+
+   Returns the libuv error code equivalent to the given platform dependent error
+   code: POSIX error codes on Unix (the ones stored in `errno`), and Win32 error
+   codes on Windows (those returned by `GetLastError()` or `WSAGetLastError()`).
+
+   If `sys_errno` is already a libuv error, it is simply returned.
+
+   .. versionchanged:: 1.10.0 function declared public.

deps/uv/docs/src/fs.rst

@@ -0,0 +1,727 @@
+
+.. _fs:
+
+File system operations
+======================
+
+libuv provides a wide variety of cross-platform sync and async file system
+operations. All functions defined in this document take a callback, which is
+allowed to be NULL. If the callback is NULL the request is completed synchronously,
+otherwise it will be performed asynchronously.
+
+All file operations are run on the threadpool. See :ref:`threadpool` for information
+on the threadpool size.
+
+Starting with libuv v1.45.0, some file operations on Linux are handed off to
+`io_uring <https://en.wikipedia.org/wiki/Io_uring>` when possible. Apart from
+a (sometimes significant) increase in throughput there should be no change in
+observable behavior. Libuv reverts to using its threadpool when the necessary
+kernel features are unavailable or unsuitable. Starting with libuv v1.49.0 this
+behavior was reverted and Libuv on Linux by default will be using the threadpool
+again. In order to enable io_uring the :c:type:`uv_loop_t` instance must be
+configured with the :c:type:`UV_LOOP_ENABLE_IO_URING_SQPOLL` option.
+
+.. note::
+     On Windows `uv_fs_*` functions use utf-8 encoding.
+
+Data types
+----------
+
+.. c:type:: uv_fs_t
+
+    File system request type.
+
+.. c:type:: uv_timespec_t
+
+    Y2K38-unsafe data type for storing times with nanosecond resolution.
+    Will be replaced with :c:type:`uv_timespec64_t` in libuv v2.0.
+
+    ::
+
+        typedef struct {
+            long tv_sec;
+            long tv_nsec;
+        } uv_timespec_t;
+
+.. c:type:: uv_stat_t
+
+    Portable equivalent of ``struct stat``.
+
+    ::
+
+        typedef struct {
+            uint64_t st_dev;
+            uint64_t st_mode;
+            uint64_t st_nlink;
+            uint64_t st_uid;
+            uint64_t st_gid;
+            uint64_t st_rdev;
+            uint64_t st_ino;
+            uint64_t st_size;
+            uint64_t st_blksize;
+            uint64_t st_blocks;
+            uint64_t st_flags;
+            uint64_t st_gen;
+            uv_timespec_t st_atim;
+            uv_timespec_t st_mtim;
+            uv_timespec_t st_ctim;
+            uv_timespec_t st_birthtim;
+        } uv_stat_t;
+
+.. c:enum:: uv_fs_type
+
+    File system request type.
+
+    ::
+
+        typedef enum {
+            UV_FS_UNKNOWN = -1,
+            UV_FS_CUSTOM,
+            UV_FS_OPEN,
+            UV_FS_CLOSE,
+            UV_FS_READ,
+            UV_FS_WRITE,
+            UV_FS_SENDFILE,
+            UV_FS_STAT,
+            UV_FS_LSTAT,
+            UV_FS_FSTAT,
+            UV_FS_FTRUNCATE,
+            UV_FS_UTIME,
+            UV_FS_FUTIME,
+            UV_FS_ACCESS,
+            UV_FS_CHMOD,
+            UV_FS_FCHMOD,
+            UV_FS_FSYNC,
+            UV_FS_FDATASYNC,
+            UV_FS_UNLINK,
+            UV_FS_RMDIR,
+            UV_FS_MKDIR,
+            UV_FS_MKDTEMP,
+            UV_FS_RENAME,
+            UV_FS_SCANDIR,
+            UV_FS_LINK,
+            UV_FS_SYMLINK,
+            UV_FS_READLINK,
+            UV_FS_CHOWN,
+            UV_FS_FCHOWN,
+            UV_FS_REALPATH,
+            UV_FS_COPYFILE,
+            UV_FS_LCHOWN,
+            UV_FS_OPENDIR,
+            UV_FS_READDIR,
+            UV_FS_CLOSEDIR,
+            UV_FS_MKSTEMP,
+            UV_FS_LUTIME
+        } uv_fs_type;
+
+.. c:type:: uv_statfs_t
+
+    Reduced cross platform equivalent of ``struct statfs``.
+    Used in :c:func:`uv_fs_statfs`.
+
+    ::
+
+        typedef struct uv_statfs_s {
+            uint64_t f_type;
+            uint64_t f_bsize;
+            uint64_t f_blocks;
+            uint64_t f_bfree;
+            uint64_t f_bavail;
+            uint64_t f_files;
+            uint64_t f_ffree;
+            uint64_t f_spare[4];
+        } uv_statfs_t;
+
+.. c:enum:: uv_dirent_type_t
+
+    Type of dirent.
+
+    ::
+
+        typedef enum {
+            UV_DIRENT_UNKNOWN,
+            UV_DIRENT_FILE,
+            UV_DIRENT_DIR,
+            UV_DIRENT_LINK,
+            UV_DIRENT_FIFO,
+            UV_DIRENT_SOCKET,
+            UV_DIRENT_CHAR,
+            UV_DIRENT_BLOCK
+        } uv_dirent_type_t;
+
+
+.. c:type:: uv_dirent_t
+
+    Cross platform (reduced) equivalent of ``struct dirent``.
+    Used in :c:func:`uv_fs_scandir_next`.
+
+    ::
+
+        typedef struct uv_dirent_s {
+            const char* name;
+            uv_dirent_type_t type;
+        } uv_dirent_t;
+
+.. c:type:: uv_dir_t
+
+    Data type used for streaming directory iteration.
+    Used by :c:func:`uv_fs_opendir()`, :c:func:`uv_fs_readdir()`, and
+    :c:func:`uv_fs_closedir()`. `dirents` represents a user provided array of
+    `uv_dirent_t`s used to hold results. `nentries` is the user provided maximum
+    array size of `dirents`.
+
+    ::
+
+        typedef struct uv_dir_s {
+            uv_dirent_t* dirents;
+            size_t nentries;
+        } uv_dir_t;
+
+.. c:type:: void (*uv_fs_cb)(uv_fs_t* req)
+
+    Callback called when a request is completed asynchronously.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: uv_loop_t* uv_fs_t.loop
+
+    Loop that started this request and where completion will be reported.
+    Readonly.
+
+.. c:member:: uv_fs_type uv_fs_t.fs_type
+
+    FS request type.
+
+.. c:member:: const char* uv_fs_t.path
+
+    Path affecting the request.
+
+.. c:member:: ssize_t uv_fs_t.result
+
+    Result of the request. < 0 means error, success otherwise. On requests such
+    as :c:func:`uv_fs_read` or :c:func:`uv_fs_write` it indicates the amount of
+    data that was read or written, respectively.
+
+.. c:member:: uv_stat_t uv_fs_t.statbuf
+
+    Stores the result of :c:func:`uv_fs_stat` and other stat requests.
+
+.. c:member:: void* uv_fs_t.ptr
+
+    Stores the result of :c:func:`uv_fs_readlink` and
+    :c:func:`uv_fs_realpath` and serves as an alias to `statbuf`.
+
+.. seealso:: The :c:type:`uv_req_t` members also apply.
+
+
+API
+---
+
+.. c:function:: void uv_fs_req_cleanup(uv_fs_t* req)
+
+    Cleanup request. Must be called after a request is finished to deallocate
+    any memory libuv might have allocated.
+
+.. c:function:: int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
+
+    Equivalent to :man:`close(2)`.
+
+.. c:function:: int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb)
+
+    Equivalent to :man:`open(2)`.
+
+    .. note::
+        On Windows libuv uses `CreateFileW` and thus the file is always opened
+        in binary mode. Because of this the O_BINARY and O_TEXT flags are not
+        supported.
+
+.. c:function:: int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
+
+    Equivalent to :man:`preadv(2)`. If the `offset` argument is `-1`, then
+    the current file offset is used and updated.
+
+    .. warning::
+        On Windows, under non-MSVC environments (e.g. when GCC or Clang is used
+        to build libuv), files opened using ``UV_FS_O_FILEMAP`` may cause a fatal
+        crash if the memory mapped read operation fails.
+
+.. c:function:: int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`unlink(2)`.
+
+.. c:function:: int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
+
+    Equivalent to :man:`pwritev(2)`. If the `offset` argument is `-1`, then
+    the current file offset is used and updated.
+
+    .. warning::
+        On Windows, under non-MSVC environments (e.g. when GCC or Clang is used
+        to build libuv), files opened using ``UV_FS_O_FILEMAP`` may cause a fatal
+        crash if the memory mapped write operation fails.
+
+.. c:function:: int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb)
+
+    Equivalent to :man:`mkdir(2)`.
+
+    .. note::
+        `mode` is currently not implemented on Windows.
+
+.. c:function:: int uv_fs_mkdtemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl, uv_fs_cb cb)
+
+    Equivalent to :man:`mkdtemp(3)`. The result can be found as a null terminated string at `req->path`.
+
+.. c:function:: int uv_fs_mkstemp(uv_loop_t* loop, uv_fs_t* req, const char* tpl, uv_fs_cb cb)
+
+    Equivalent to :man:`mkstemp(3)`. The created file path can be found as a null terminated string at `req->path`.
+    The file descriptor can be found as an integer at `req->result`.
+
+    .. versionadded:: 1.34.0
+
+.. c:function:: int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`rmdir(2)`.
+
+.. c:function:: int uv_fs_opendir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Opens `path` as a directory stream. On success, a `uv_dir_t` is allocated
+    and returned via `req->ptr`. This memory is not freed by
+    `uv_fs_req_cleanup()`, although `req->ptr` is set to `NULL`. The allocated
+    memory must be freed by calling `uv_fs_closedir()`. On failure, no memory
+    is allocated.
+
+    The contents of the directory can be iterated over by passing the resulting
+    `uv_dir_t` to `uv_fs_readdir()`.
+
+    .. versionadded:: 1.28.0
+
+.. c:function:: int uv_fs_closedir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb)
+
+    Closes the directory stream represented by `dir` and frees the memory
+    allocated by `uv_fs_opendir()`.
+
+    .. versionadded:: 1.28.0
+
+.. c:function:: int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, uv_dir_t* dir, uv_fs_cb cb)
+
+    Iterates over the directory stream, `dir`, returned by a successful
+    `uv_fs_opendir()` call. Prior to invoking `uv_fs_readdir()`, the caller
+    must set `dir->dirents` and `dir->nentries`, representing the array of
+    :c:type:`uv_dirent_t` elements used to hold the read directory entries and
+    its size.
+
+    On success, the result is an integer >= 0 representing the number of entries
+    read from the stream.
+
+    .. versionadded:: 1.28.0
+
+    .. warning::
+        `uv_fs_readdir()` is not thread safe.
+
+    .. note::
+        This function does not return the "." and ".." entries.
+
+    .. note::
+        On success this function allocates memory that must be freed using
+        `uv_fs_req_cleanup()`. `uv_fs_req_cleanup()` must be called before
+        closing the directory with `uv_fs_closedir()`.
+
+.. c:function:: int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb)
+.. c:function:: int uv_fs_scandir_next(uv_fs_t* req, uv_dirent_t* ent)
+
+    Equivalent to :man:`scandir(3)`, with a slightly different API. Once the callback
+    for the request is called, the user can use :c:func:`uv_fs_scandir_next` to
+    get `ent` populated with the next directory entry data. When there are no
+    more entries ``UV_EOF`` will be returned.
+
+    .. note::
+        Unlike `scandir(3)`, this function does not return the "." and ".." entries.
+
+    .. note::
+        On Linux, getting the type of an entry is only supported by some file systems (btrfs, ext2,
+        ext3 and ext4 at the time of this writing), check the :man:`getdents(2)` man page.
+
+.. c:function:: int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+.. c:function:: int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
+.. c:function:: int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`stat(2)`, :man:`fstat(2)` and :man:`lstat(2)` respectively.
+
+.. c:function:: int uv_fs_statfs(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`statfs(2)`. On success, a `uv_statfs_t` is allocated
+    and returned via `req->ptr`. This memory is freed by `uv_fs_req_cleanup()`.
+
+    .. note::
+        Any fields in the resulting `uv_statfs_t` that are not supported by the
+        underlying operating system are set to zero.
+
+    .. versionadded:: 1.31.0
+
+.. c:function:: int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb)
+
+    Equivalent to :man:`rename(2)`.
+
+.. c:function:: int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
+
+    Equivalent to :man:`fsync(2)`.
+
+    .. note::
+        For AIX, `uv_fs_fsync` returns `UV_EBADF` on file descriptors referencing
+        non regular files.
+
+.. c:function:: int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb)
+
+    Equivalent to :man:`fdatasync(2)`.
+
+.. c:function:: int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, int64_t offset, uv_fs_cb cb)
+
+    Equivalent to :man:`ftruncate(2)`.
+
+.. c:function:: int uv_fs_copyfile(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, int flags, uv_fs_cb cb)
+
+    Copies a file from `path` to `new_path`. Supported `flags` are described below.
+
+    - `UV_FS_COPYFILE_EXCL`: If present, `uv_fs_copyfile()` will fail with
+      `UV_EEXIST` if the destination path already exists. The default behavior
+      is to overwrite the destination if it exists.
+    - `UV_FS_COPYFILE_FICLONE`: If present, `uv_fs_copyfile()` will attempt to
+      create a copy-on-write reflink. If the underlying platform does not
+      support copy-on-write, or an error occurs while attempting to use
+      copy-on-write, a fallback copy mechanism based on
+      :c:func:`uv_fs_sendfile()` is used.
+    - `UV_FS_COPYFILE_FICLONE_FORCE`: If present, `uv_fs_copyfile()` will
+      attempt to create a copy-on-write reflink. If the underlying platform does
+      not support copy-on-write, or an error occurs while attempting to use
+      copy-on-write, then an error is returned.
+
+    .. warning::
+        If the destination path is created, but an error occurs while copying
+        the data, then the destination path is removed. There is a brief window
+        of time between closing and removing the file where another process
+        could access the file.
+
+    .. versionadded:: 1.14.0
+
+    .. versionchanged:: 1.20.0 `UV_FS_COPYFILE_FICLONE` and
+        `UV_FS_COPYFILE_FICLONE_FORCE` are supported.
+
+    .. versionchanged:: 1.33.0 If an error occurs while using
+        `UV_FS_COPYFILE_FICLONE_FORCE`, that error is returned. Previously,
+        all errors were mapped to `UV_ENOTSUP`.
+
+.. c:function:: int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, uv_file in_fd, int64_t in_offset, size_t length, uv_fs_cb cb)
+
+    Limited equivalent to :man:`sendfile(2)`.
+
+.. c:function:: int uv_fs_access(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb)
+
+    Equivalent to :man:`access(2)` on Unix. Windows uses ``GetFileAttributesW()``.
+
+.. c:function:: int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb)
+.. c:function:: int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode, uv_fs_cb cb)
+
+    Equivalent to :man:`chmod(2)` and :man:`fchmod(2)` respectively.
+
+.. c:function:: int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb)
+.. c:function:: int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime, double mtime, uv_fs_cb cb)
+.. c:function:: int uv_fs_lutime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb)
+
+    Equivalent to :man:`utime(2)`, :man:`futimes(3)` and :man:`lutimes(3)` respectively.
+
+    Passing `UV_FS_UTIME_NOW` as the atime or mtime sets the timestamp to the
+    current time.
+
+    Passing `UV_FS_UTIME_OMIT` as the atime or mtime leaves the timestamp
+    untouched.
+
+    .. note::
+      z/OS: `uv_fs_lutime()` is not implemented for z/OS. It can still be called but will return
+      ``UV_ENOSYS``.
+
+    .. note::
+      AIX: `uv_fs_futime()` and `uv_fs_lutime()` functions only work for AIX 7.1 and newer.
+      They can still be called on older versions but will return ``UV_ENOSYS``.
+
+    .. versionchanged:: 1.10.0 sub-second precission is supported on Windows
+
+.. c:function:: int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb)
+
+    Equivalent to :man:`link(2)`.
+
+.. c:function:: int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, int flags, uv_fs_cb cb)
+
+    Equivalent to :man:`symlink(2)`.
+
+    .. note::
+        On Windows the `flags` parameter can be specified to control how the symlink will
+        be created:
+
+            * ``UV_FS_SYMLINK_DIR``: indicates that `path` points to a directory.
+
+            * ``UV_FS_SYMLINK_JUNCTION``: request that the symlink is created
+              using junction points.
+
+.. c:function:: int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`readlink(2)`.
+    The resulting string is stored in `req->ptr`.
+
+.. c:function:: int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb)
+
+    Equivalent to :man:`realpath(3)` on Unix. Windows uses `GetFinalPathNameByHandleW <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfinalpathnamebyhandlew>`_.
+    The resulting string is stored in `req->ptr`.
+
+    .. warning::
+        This function has certain platform-specific caveats that were discovered when used in Node.
+
+        * macOS and other BSDs: this function will fail with UV_ELOOP if more than 32 symlinks are
+          found while resolving the given path.  This limit is hardcoded and cannot be sidestepped.
+        * Windows: while this function works in the common case, there are a number of corner cases
+          where it doesn't:
+
+          - Paths in ramdisk volumes created by tools which sidestep the Volume Manager (such as ImDisk)
+            cannot be resolved.
+          - Inconsistent casing when using drive letters.
+          - Resolved path bypasses subst'd drives.
+
+        While this function can still be used, it's not recommended if scenarios such as the
+        above need to be supported.
+
+        The background story and some more details on these issues can be checked
+        `here <https://github.com/nodejs/node/issues/7726>`_.
+
+    .. versionadded:: 1.8.0
+
+.. c:function:: int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
+.. c:function:: int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
+.. c:function:: int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
+
+    Equivalent to :man:`chown(2)`, :man:`fchown(2)` and :man:`lchown(2)` respectively.
+
+    .. note::
+        These functions are not implemented on Windows.
+
+    .. versionchanged:: 1.21.0 implemented uv_fs_lchown
+
+.. c:function:: uv_fs_type uv_fs_get_type(const uv_fs_t* req)
+
+    Returns `req->fs_type`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: ssize_t uv_fs_get_result(const uv_fs_t* req)
+
+    Returns `req->result`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: int uv_fs_get_system_error(const uv_fs_t* req)
+
+    Returns the platform specific error code - `GetLastError()` value on Windows
+    and `-(req->result)` on other platforms.
+
+    .. versionadded:: 1.38.0
+
+.. c:function:: void* uv_fs_get_ptr(const uv_fs_t* req)
+
+    Returns `req->ptr`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: const char* uv_fs_get_path(const uv_fs_t* req)
+
+    Returns `req->path`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: uv_stat_t* uv_fs_get_statbuf(uv_fs_t* req)
+
+    Returns `&req->statbuf`.
+
+    .. versionadded:: 1.19.0
+
+.. seealso:: The :c:type:`uv_req_t` API functions also apply.
+
+Helper functions
+----------------
+
+.. c:function:: uv_os_fd_t uv_get_osfhandle(int fd)
+
+   For a file descriptor in the C runtime, get the OS-dependent handle.
+   On UNIX, returns the ``fd`` intact. On Windows, this calls `_get_osfhandle <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle?view=vs-2019>`_.
+   Note that the return value is still owned by the C runtime,
+   any attempts to close it or to use it after closing the fd may lead to malfunction.
+
+    .. versionadded:: 1.12.0
+
+.. c:function:: int uv_open_osfhandle(uv_os_fd_t os_fd)
+
+   For a OS-dependent handle, get the file descriptor in the C runtime.
+   On UNIX, returns the ``os_fd`` intact. On Windows, this calls `_open_osfhandle <https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/open-osfhandle?view=vs-2019>`_.
+   Note that this consumes the argument, any attempts to close it or to use it
+   after closing the return value may lead to malfunction.
+
+    .. versionadded:: 1.23.0
+
+File open constants
+-------------------
+
+.. c:macro:: UV_FS_O_APPEND
+
+    The file is opened in append mode. Before each write, the file offset is
+    positioned at the end of the file.
+
+.. c:macro:: UV_FS_O_CREAT
+
+    The file is created if it does not already exist.
+
+.. c:macro:: UV_FS_O_DIRECT
+
+    File I/O is done directly to and from user-space buffers, which must be
+    aligned. Buffer size and address should be a multiple of the physical sector
+    size of the block device.
+
+    .. note::
+        `UV_FS_O_DIRECT` is supported on Linux, and on Windows via
+        `FILE_FLAG_NO_BUFFERING <https://docs.microsoft.com/en-us/windows/win32/fileio/file-buffering>`_.
+        `UV_FS_O_DIRECT` is not supported on macOS.
+
+.. c:macro:: UV_FS_O_DIRECTORY
+
+    If the path is not a directory, fail the open.
+
+    .. note::
+        `UV_FS_O_DIRECTORY` is not supported on Windows.
+
+.. c:macro:: UV_FS_O_DSYNC
+
+    The file is opened for synchronous I/O. Write operations will complete once
+    all data and a minimum of metadata are flushed to disk.
+
+    .. note::
+        `UV_FS_O_DSYNC` is supported on Windows via
+        `FILE_FLAG_WRITE_THROUGH <https://docs.microsoft.com/en-us/windows/win32/fileio/file-buffering>`_.
+
+.. c:macro:: UV_FS_O_EXCL
+
+    If the `O_CREAT` flag is set and the file already exists, fail the open.
+
+    .. note::
+        In general, the behavior of `O_EXCL` is undefined if it is used without
+        `O_CREAT`. There is one exception: on Linux 2.6 and later, `O_EXCL` can
+        be used without `O_CREAT` if pathname refers to a block device. If the
+        block device is in use by the system (e.g., mounted), the open will fail
+        with the error `EBUSY`.
+
+.. c:macro:: UV_FS_O_EXLOCK
+
+    Atomically obtain an exclusive lock.
+
+    .. note::
+        `UV_FS_O_EXLOCK` is only supported on macOS and Windows.
+
+    .. versionchanged:: 1.17.0 support is added for Windows.
+
+.. c:macro:: UV_FS_O_FILEMAP
+
+    Use a memory file mapping to access the file. When using this flag, the
+    file cannot be open multiple times concurrently.
+
+    .. note::
+        `UV_FS_O_FILEMAP` is only supported on Windows.
+
+.. c:macro:: UV_FS_O_NOATIME
+
+    Do not update the file access time when the file is read.
+
+    .. note::
+        `UV_FS_O_NOATIME` is not supported on Windows.
+
+.. c:macro:: UV_FS_O_NOCTTY
+
+    If the path identifies a terminal device, opening the path will not cause
+    that terminal to become the controlling terminal for the process (if the
+    process does not already have one).
+
+    .. note::
+        `UV_FS_O_NOCTTY` is not supported on Windows.
+
+.. c:macro:: UV_FS_O_NOFOLLOW
+
+    If the path is a symbolic link, fail the open.
+
+    .. note::
+        `UV_FS_O_NOFOLLOW` is not supported on Windows.
+
+.. c:macro:: UV_FS_O_NONBLOCK
+
+    Open the file in nonblocking mode if possible.
+
+    .. note::
+        `UV_FS_O_NONBLOCK` is not supported on Windows.
+
+.. c:macro:: UV_FS_O_RANDOM
+
+    Access is intended to be random. The system can use this as a hint to
+    optimize file caching.
+
+    .. note::
+        `UV_FS_O_RANDOM` is only supported on Windows via
+        `FILE_FLAG_RANDOM_ACCESS <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew>`_.
+
+.. c:macro:: UV_FS_O_RDONLY
+
+    Open the file for read-only access.
+
+.. c:macro:: UV_FS_O_RDWR
+
+    Open the file for read-write access.
+
+.. c:macro:: UV_FS_O_SEQUENTIAL
+
+    Access is intended to be sequential from beginning to end. The system can
+    use this as a hint to optimize file caching.
+
+    .. note::
+        `UV_FS_O_SEQUENTIAL` is only supported on Windows via
+        `FILE_FLAG_SEQUENTIAL_SCAN <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew>`_.
+
+.. c:macro:: UV_FS_O_SHORT_LIVED
+
+    The file is temporary and should not be flushed to disk if possible.
+
+    .. note::
+        `UV_FS_O_SHORT_LIVED` is only supported on Windows via
+        `FILE_ATTRIBUTE_TEMPORARY <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew>`_.
+
+.. c:macro:: UV_FS_O_SYMLINK
+
+    Open the symbolic link itself rather than the resource it points to.
+
+.. c:macro:: UV_FS_O_SYNC
+
+    The file is opened for synchronous I/O. Write operations will complete once
+    all data and all metadata are flushed to disk.
+
+    .. note::
+        `UV_FS_O_SYNC` is supported on Windows via
+        `FILE_FLAG_WRITE_THROUGH <https://docs.microsoft.com/en-us/windows/win32/fileio/file-buffering>`_.
+
+.. c:macro:: UV_FS_O_TEMPORARY
+
+    The file is temporary and should not be flushed to disk if possible.
+
+    .. note::
+        `UV_FS_O_TEMPORARY` is only supported on Windows via
+        `FILE_ATTRIBUTE_TEMPORARY <https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew>`_.
+
+.. c:macro:: UV_FS_O_TRUNC
+
+    If the file exists and is a regular file, and the file is opened
+    successfully for write access, its length shall be truncated to zero.
+
+.. c:macro:: UV_FS_O_WRONLY
+
+    Open the file for write-only access.

deps/uv/docs/src/fs_event.rst

@@ -0,0 +1,144 @@
+
+.. _fs_event:
+
+:c:type:`uv_fs_event_t` --- FS Event handle
+===========================================
+
+FS Event handles allow the user to monitor a given path for changes, for example,
+if the file was renamed or there was a generic change in it. This handle uses
+the best backend for the job on each platform.
+
+.. note::
+    For AIX, the non default IBM bos.ahafs package has to be installed.
+    The AIX Event Infrastructure file system (ahafs) has some limitations:
+
+        - ahafs tracks monitoring per process and is not thread safe. A separate process
+          must be spawned for each monitor for the same event.
+        - Events for file modification (writing to a file) are not received if only the
+          containing folder is watched.
+
+    See documentation_ for more details.
+
+    The z/OS file system events monitoring infrastructure does not notify of file
+    creation/deletion within a directory that is being monitored.
+    See the `IBM Knowledge centre`_ for more details.
+
+    .. _documentation: https://developer.ibm.com/articles/au-aix_event_infrastructure/
+    .. _`IBM Knowledge centre`: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.2.0/com.ibm.zos.v2r1.bpxb100/ioc.htm
+
+
+
+
+Data types
+----------
+
+.. c:type:: uv_fs_event_t
+
+    FS Event handle type.
+
+.. c:type:: void (*uv_fs_event_cb)(uv_fs_event_t* handle, const char* filename, int events, int status)
+
+    Callback passed to :c:func:`uv_fs_event_start` which will be called repeatedly
+    after the handle is started.
+
+    If the handle was started with a directory the `filename` parameter will
+    be a relative path to a file contained in the directory, or `NULL` if the
+    file name cannot be determined.
+
+    The `events` parameter is an ORed mask of :c:enum:`uv_fs_event` elements.
+
+.. note::
+   For FreeBSD path could sometimes be `NULL` due to a kernel bug.
+
+    .. _Reference: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=197695
+
+.. c:enum:: uv_fs_event
+
+    Event types that :c:type:`uv_fs_event_t` handles monitor.
+
+    ::
+
+        enum uv_fs_event {
+            UV_RENAME = 1,
+            UV_CHANGE = 2
+        };
+
+.. c:enum:: uv_fs_event_flags
+
+    Flags that can be passed to :c:func:`uv_fs_event_start` to control its
+    behavior.
+
+    ::
+
+        enum uv_fs_event_flags {
+            /*
+            * By default, if the fs event watcher is given a directory name, we will
+            * watch for all events in that directory. This flags overrides this behavior
+            * and makes fs_event report only changes to the directory entry itself. This
+            * flag does not affect individual files watched.
+            * This flag is currently not implemented yet on any backend.
+            */
+            UV_FS_EVENT_WATCH_ENTRY = 1,
+            /*
+            * By default uv_fs_event will try to use a kernel interface such as inotify
+            * or kqueue to detect events. This may not work on remote file systems such
+            * as NFS mounts. This flag makes fs_event fall back to calling stat() on a
+            * regular interval.
+            * This flag is currently not implemented yet on any backend.
+            */
+            UV_FS_EVENT_STAT = 2,
+            /*
+            * By default, event watcher, when watching directory, is not registering
+            * (is ignoring) changes in its subdirectories.
+            * This flag will override this behaviour on platforms that support it.
+            */
+            UV_FS_EVENT_RECURSIVE = 4
+        };
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle)
+
+    Initialize the handle.
+
+.. c:function:: int uv_fs_event_start(uv_fs_event_t* handle, uv_fs_event_cb cb, const char* path, unsigned int flags)
+
+    Start the handle with the given callback, which will watch the specified
+    `path` for changes. `flags` can be an ORed mask of :c:enum:`uv_fs_event_flags`.
+
+    .. note:: Currently the only supported flag is ``UV_FS_EVENT_RECURSIVE`` and
+              only on OSX and Windows.
+    .. note:: On macOS, events collected by the OS immediately before calling
+              ``uv_fs_event_start`` might be reported to the `uv_fs_event_cb`
+              callback.
+
+.. c:function:: int uv_fs_event_stop(uv_fs_event_t* handle)
+
+    Stop the handle, the callback will no longer be called.
+
+.. c:function:: int uv_fs_event_getpath(uv_fs_event_t* handle, char* buffer, size_t* size)
+
+    Get the path being monitored by the handle. The buffer must be preallocated
+    by the user. Returns 0 on success or an error code < 0 in case of failure.
+    On success, `buffer` will contain the path and `size` its length. If the buffer
+    is not big enough `UV_ENOBUFS` will be returned and `size` will be set to
+    the required size, including the null terminator.
+
+    .. versionchanged:: 1.3.0 the returned length no longer includes the terminating null byte,
+                        and the buffer is not null terminated.
+
+    .. versionchanged:: 1.9.0 the returned length includes the terminating null
+                        byte on `UV_ENOBUFS`, and the buffer is null terminated
+                        on success.
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/fs_poll.rst

@@ -0,0 +1,77 @@
+
+.. _fs_poll:
+
+:c:type:`uv_fs_poll_t` --- FS Poll handle
+=========================================
+
+FS Poll handles allow the user to monitor a given path for changes. Unlike
+:c:type:`uv_fs_event_t`, fs poll handles use `stat` to detect when a file has
+changed so they can work on file systems where fs event handles can't.
+
+
+Data types
+----------
+
+.. c:type:: uv_fs_poll_t
+
+    FS Poll handle type.
+
+.. c:type:: void (*uv_fs_poll_cb)(uv_fs_poll_t* handle, int status, const uv_stat_t* prev, const uv_stat_t* curr)
+
+    Callback passed to :c:func:`uv_fs_poll_start` which will be called repeatedly
+    after the handle is started, when any change happens to the monitored path.
+
+    The callback is invoked with `status < 0` if `path` does not exist
+    or is inaccessible. The watcher is *not* stopped but your callback is
+    not called again until something changes (e.g. when the file is created
+    or the error reason changes).
+
+    When `status == 0`, the callback receives pointers to the old and new
+    :c:type:`uv_stat_t` structs. They are valid for the duration of the
+    callback only.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle)
+
+    Initialize the handle.
+
+.. c:function:: int uv_fs_poll_start(uv_fs_poll_t* handle, uv_fs_poll_cb poll_cb, const char* path, unsigned int interval)
+
+    Check the file at `path` for changes every `interval` milliseconds.
+
+    .. note::
+        For maximum portability, use multi-second intervals. Sub-second intervals will not detect
+        all changes on many file systems.
+
+.. c:function:: int uv_fs_poll_stop(uv_fs_poll_t* handle)
+
+    Stop the handle, the callback will no longer be called.
+
+.. c:function:: int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size)
+
+    Get the path being monitored by the handle. The buffer must be preallocated
+    by the user. Returns 0 on success or an error code < 0 in case of failure.
+    On success, `buffer` will contain the path and `size` its length. If the buffer
+    is not big enough `UV_ENOBUFS` will be returned and `size` will be set to
+    the required size.
+
+    .. versionchanged:: 1.3.0 the returned length no longer includes the terminating null byte,
+                        and the buffer is not null terminated.
+
+    .. versionchanged:: 1.9.0 the returned length includes the terminating null
+                        byte on `UV_ENOBUFS`, and the buffer is null terminated
+                        on success.
+
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/guide.rst

@@ -0,0 +1,22 @@
+.. _guide:
+
+User guide
+==========
+
+.. warning::
+    The contents of this guide have been recently incorporated into the libuv documentation
+    and it hasn't gone through thorough review yet. If you spot a mistake please file an
+    issue, or better yet, open a pull request!
+
+.. toctree::
+   :maxdepth: 2
+
+   guide/introduction
+   guide/basics
+   guide/filesystem
+   guide/networking
+   guide/threads
+   guide/processes
+   guide/eventloops
+   guide/utilities
+   guide/about

deps/uv/docs/src/handle.rst

@@ -0,0 +1,286 @@
+
+.. _handle:
+
+:c:type:`uv_handle_t` --- Base handle
+=====================================
+
+`uv_handle_t` is the base type for all libuv handle types.
+
+Structures are aligned so that any libuv handle can be cast to `uv_handle_t`.
+All API functions defined here work with any handle type.
+
+Libuv handles are not movable. Pointers to handle structures passed to
+functions must remain valid for the duration of the requested operation. Take
+care when using stack allocated handles.
+
+Data types
+----------
+
+.. c:type:: uv_handle_t
+
+    The base libuv handle type.
+
+.. c:enum:: uv_handle_type
+
+    The kind of the libuv handle.
+
+    ::
+
+        typedef enum {
+          UV_UNKNOWN_HANDLE = 0,
+          UV_ASYNC,
+          UV_CHECK,
+          UV_FS_EVENT,
+          UV_FS_POLL,
+          UV_HANDLE,
+          UV_IDLE,
+          UV_NAMED_PIPE,
+          UV_POLL,
+          UV_PREPARE,
+          UV_PROCESS,
+          UV_STREAM,
+          UV_TCP,
+          UV_TIMER,
+          UV_TTY,
+          UV_UDP,
+          UV_SIGNAL,
+          UV_FILE,
+          UV_HANDLE_TYPE_MAX
+        } uv_handle_type;
+
+.. c:type:: uv_any_handle
+
+    Union of all handle types.
+
+.. c:type:: void (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
+
+    Type definition for callback passed to :c:func:`uv_read_start` and
+    :c:func:`uv_udp_recv_start`. The user must allocate memory and fill the supplied
+    :c:type:`uv_buf_t` structure. If NULL is assigned as the buffer's base or 0 as its length,
+    a ``UV_ENOBUFS`` error will be triggered in the :c:type:`uv_udp_recv_cb` or the
+    :c:type:`uv_read_cb` callback.
+
+    Each buffer is used only once and the user is responsible for freeing it in the
+    :c:type:`uv_udp_recv_cb` or the :c:type:`uv_read_cb` callback.
+
+    A suggested size (65536 at the moment in most cases) is provided, but it's just an indication,
+    not related in any way to the pending data to be read. The user is free to allocate the amount
+    of memory they decide.
+
+    As an example, applications with custom allocation schemes such as using freelists, allocation
+    pools or slab based allocators may decide to use a different size which matches the memory
+    chunks they already have.
+
+    Example:
+
+    ::
+
+        static void my_alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
+          buf->base = malloc(suggested_size);
+          buf->len = suggested_size;
+        }
+
+.. c:type:: void (*uv_close_cb)(uv_handle_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_close`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: uv_loop_t* uv_handle_t.loop
+
+    Pointer to the :c:type:`uv_loop_t` the handle is running on. Readonly.
+
+.. c:member:: uv_handle_type uv_handle_t.type
+
+    The :c:enum:`uv_handle_type`, indicating the type of the underlying handle. Readonly.
+
+.. c:member:: void* uv_handle_t.data
+
+    Space for user-defined arbitrary data. libuv does not use this field.
+
+
+API
+---
+
+.. c:macro:: UV_HANDLE_TYPE_MAP(iter_macro)
+
+    Macro that expands to a series of invocations of `iter_macro` for
+    each of the handle types. `iter_macro` is invoked with two
+    arguments: the name of the `uv_handle_type` element without the
+    `UV_` prefix, and the name of the corresponding structure type
+    without the `uv_` prefix and `_t` suffix.
+
+.. c:function:: int uv_is_active(const uv_handle_t* handle)
+
+    Returns non-zero if the handle is active, zero if it's inactive. What
+    "active" means depends on the type of handle:
+
+    - A uv_async_t handle is always active and cannot be deactivated, except
+      by closing it with uv_close().
+
+    - A uv_pipe_t, uv_tcp_t, uv_udp_t, etc. handle - basically any handle that
+      deals with i/o - is active when it is doing something that involves i/o,
+      like reading, writing, connecting, accepting new connections, etc.
+
+    - A uv_check_t, uv_idle_t, uv_timer_t, etc. handle is active when it has
+      been started with a call to uv_check_start(), uv_idle_start(), etc.
+
+    Rule of thumb: if a handle of type `uv_foo_t` has a `uv_foo_start()`
+    function, then it's active from the moment that function is called.
+    Likewise, `uv_foo_stop()` deactivates the handle again.
+
+.. c:function:: int uv_is_closing(const uv_handle_t* handle)
+
+    Returns non-zero if the handle is closing or closed, zero otherwise.
+
+    .. note::
+        This function should only be used between the initialization of the handle and the
+        arrival of the close callback.
+
+.. c:function:: void uv_close(uv_handle_t* handle, uv_close_cb close_cb)
+
+    Request handle to be closed. `close_cb` will be called asynchronously after
+    this call. This MUST be called on each handle before memory is released.
+    Moreover, the memory can only be released in `close_cb` or after it has
+    returned.
+
+    Handles that wrap file descriptors are closed immediately but
+    `close_cb` will still be deferred to the next iteration of the event loop.
+    It gives you a chance to free up any resources associated with the handle.
+
+    In-progress requests, like uv_connect_t or uv_write_t, are cancelled and
+    have their callbacks called asynchronously with status=UV_ECANCELED.
+
+    `close_cb` can be `NULL` in cases where no cleanup or deallocation is
+    necessary.
+
+.. c:function:: void uv_ref(uv_handle_t* handle)
+
+    Reference the given handle. References are idempotent, that is, if a handle
+    is already referenced calling this function again will have no effect.
+
+    See :ref:`refcount`.
+
+.. c:function:: void uv_unref(uv_handle_t* handle)
+
+    Un-reference the given handle. References are idempotent, that is, if a handle
+    is not referenced calling this function again will have no effect.
+
+    See :ref:`refcount`.
+
+.. c:function:: int uv_has_ref(const uv_handle_t* handle)
+
+    Returns non-zero if the handle referenced, zero otherwise.
+
+    See :ref:`refcount`.
+
+.. c:function:: size_t uv_handle_size(uv_handle_type type)
+
+    Returns the size of the given handle type. Useful for FFI binding writers
+    who don't want to know the structure layout.
+
+
+Miscellaneous API functions
+---------------------------
+
+The following API functions take a :c:type:`uv_handle_t` argument but they work
+just for some handle types.
+
+.. c:function:: int uv_send_buffer_size(uv_handle_t* handle, int* value)
+
+    Gets or sets the size of the send buffer that the operating
+    system uses for the socket.
+
+    If `*value` == 0, then it will set `*value` to the current send buffer size.
+    If `*value` > 0 then it will use `*value` to set the new send buffer size.
+
+    On success, zero is returned. On error, a negative result is
+    returned.
+
+    This function works for TCP, pipe and UDP handles on Unix and for TCP and
+    UDP handles on Windows.
+
+    .. note::
+        Linux will set double the size and return double the size of the original set value.
+
+.. c:function:: int uv_recv_buffer_size(uv_handle_t* handle, int* value)
+
+    Gets or sets the size of the receive buffer that the operating
+    system uses for the socket.
+
+    If `*value` == 0, then it will set `*value` to the current receive buffer size.
+    If `*value` > 0 then it will use `*value` to set the new receive buffer size.
+
+    On success, zero is returned. On error, a negative result is
+    returned.
+
+    This function works for TCP, pipe and UDP handles on Unix and for TCP and
+    UDP handles on Windows.
+
+    .. note::
+        Linux will set double the size and return double the size of the original set value.
+
+.. c:function:: int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd)
+
+    Gets the platform dependent file descriptor equivalent.
+
+    The following handles are supported: TCP, pipes, TTY, UDP and poll. Passing
+    any other handle type will fail with `UV_EINVAL`.
+
+    If a handle doesn't have an attached file descriptor yet or the handle
+    itself has been closed, this function will return `UV_EBADF`.
+
+    .. warning::
+        Be very careful when using this function. libuv assumes it's in control of the file
+        descriptor so any change to it may lead to malfunction.
+
+.. c:function:: uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle)
+
+    Returns `handle->loop`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: void* uv_handle_get_data(const uv_handle_t* handle)
+
+    Returns `handle->data`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: void uv_handle_set_data(uv_handle_t* handle, void* data)
+
+    Sets `handle->data` to `data`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: uv_handle_type uv_handle_get_type(const uv_handle_t* handle)
+
+    Returns `handle->type`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: const char* uv_handle_type_name(uv_handle_type type)
+
+    Returns the name for the equivalent struct for a given handle type,
+    e.g. `"pipe"` (as in :c:type:`uv_pipe_t`) for `UV_NAMED_PIPE`.
+
+    If no such handle type exists, this returns `NULL`.
+
+    .. versionadded:: 1.19.0
+
+.. _refcount:
+
+Reference counting
+------------------
+
+The libuv event loop (if run in the default mode) will run until there are no
+active `and` referenced handles left. The user can force the loop to exit early
+by unreferencing handles which are active, for example by calling :c:func:`uv_unref`
+after calling :c:func:`uv_timer_start`.
+
+A handle can be referenced or unreferenced, the refcounting scheme doesn't use
+a counter, so both operations are idempotent.
+
+All handles are referenced when active by default, see :c:func:`uv_is_active`
+for a more detailed explanation on what being `active` involves.

deps/uv/docs/src/idle.rst

@@ -0,0 +1,62 @@
+
+.. _idle:
+
+:c:type:`uv_idle_t` --- Idle handle
+===================================
+
+Idle handles will run the given callback once per loop iteration, right
+before the :c:type:`uv_prepare_t` handles.
+
+.. note::
+    The notable difference with prepare handles is that when there are active idle handles,
+    the loop will perform a zero timeout poll instead of blocking for i/o.
+
+.. warning::
+    Despite the name, idle handles will get their callbacks called on every loop iteration,
+    not when the loop is actually "idle".
+
+
+Data types
+----------
+
+.. c:type:: uv_idle_t
+
+    Idle handle type.
+
+.. c:type:: void (*uv_idle_cb)(uv_idle_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_idle_start`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_idle_init(uv_loop_t* loop, uv_idle_t* idle)
+
+    Initialize the handle. This function always succeeds.
+
+    :returns: 0
+
+.. c:function:: int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb)
+
+    Start the handle with the given callback. This function always succeeds,
+    except when `cb` is `NULL`.
+
+    :returns: 0 on success, or `UV_EINVAL` when `cb == NULL`.
+
+.. c:function:: int uv_idle_stop(uv_idle_t* idle)
+
+    Stop the handle, the callback will no longer be called.
+    This function always succeeds.
+
+    :returns: 0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/index.rst

@@ -0,0 +1,62 @@
+
+Welcome to the libuv documentation
+==================================
+
+Overview
+--------
+
+libuv is a multi-platform support library with a focus on asynchronous I/O. It
+was primarily developed for use by `Node.js`_, but it's also used by `Luvit`_,
+`Julia`_, `uvloop`_, and `others`_.
+
+.. note::
+    In case you find errors in this documentation you can help by sending
+    `pull requests <https://github.com/libuv/libuv>`_!
+
+.. _Node.js: https://nodejs.org
+.. _Luvit: https://luvit.io
+.. _Julia: https://julialang.org
+.. _uvloop: https://github.com/MagicStack/uvloop
+.. _others: https://github.com/libuv/libuv/blob/v1.x/LINKS.md
+
+
+Features
+--------
+
+* Full-featured event loop backed by epoll, kqueue, IOCP, event ports.
+* Asynchronous TCP and UDP sockets
+* Asynchronous DNS resolution
+* Asynchronous file and file system operations
+* File system events
+* ANSI escape code controlled TTY
+* IPC with socket sharing, using Unix domain sockets or named pipes (Windows)
+* Child processes
+* Thread pool
+* Signal handling
+* High resolution clock
+* Threading and synchronization primitives
+
+
+Documentation
+-------------
+
+.. toctree::
+   :maxdepth: 1
+
+   design
+   api
+   guide
+   upgrading
+
+
+Downloads
+---------
+
+libuv can be downloaded from `here <https://dist.libuv.org/dist/>`_.
+
+
+Installation
+------------
+
+Installation instructions can be found in the `README <https://github.com/libuv/libuv/blob/master/README.md>`_.
+

deps/uv/docs/src/loop.rst

@@ -0,0 +1,263 @@
+
+.. _loop:
+
+:c:type:`uv_loop_t` --- Event loop
+==================================
+
+The event loop is the central part of libuv's functionality. It takes care
+of polling for i/o and scheduling callbacks to be run based on different sources
+of events.
+
+
+Data types
+----------
+
+.. c:type:: uv_loop_t
+
+    Loop data type.
+
+.. c:enum:: uv_loop_option
+
+    Additional loop options.
+    See :c:func:`uv_loop_configure`.
+
+    ::
+
+        typedef enum {
+            UV_LOOP_BLOCK_SIGNAL = 0,
+            UV_METRICS_IDLE_TIME,
+            UV_LOOP_USE_IO_URING_SQPOLL
+        } uv_loop_option;
+
+.. c:enum:: uv_run_mode
+
+    Mode used to run the loop with :c:func:`uv_run`.
+
+    ::
+
+        typedef enum {
+            UV_RUN_DEFAULT = 0,
+            UV_RUN_ONCE,
+            UV_RUN_NOWAIT
+        } uv_run_mode;
+
+.. c:type:: void (*uv_walk_cb)(uv_handle_t* handle, void* arg)
+
+    Type definition for callback passed to :c:func:`uv_walk`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: void* uv_loop_t.data
+
+    Space for user-defined arbitrary data. libuv does not use and does not
+    touch this field.
+
+
+API
+---
+
+.. c:function:: int uv_loop_init(uv_loop_t* loop)
+
+    Initializes the given `uv_loop_t` structure.
+
+.. c:function:: int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...)
+
+    .. versionadded:: 1.0.2
+
+    Set additional loop options.  You should normally call this before the
+    first call to :c:func:`uv_run` unless mentioned otherwise.
+
+    Returns 0 on success or a UV_E* error code on failure.  Be prepared to
+    handle UV_ENOSYS; it means the loop option is not supported by the platform.
+
+    Supported options:
+
+    - UV_LOOP_BLOCK_SIGNAL: Block a signal when polling for new events.  The
+      second argument to :c:func:`uv_loop_configure` is the signal number.
+
+      This operation is currently only implemented for SIGPROF signals,
+      to suppress unnecessary wakeups when using a sampling profiler.
+      Requesting other signals will fail with UV_EINVAL.
+
+    - UV_METRICS_IDLE_TIME: Accumulate the amount of idle time the event loop
+      spends in the event provider.
+
+      This option is necessary to use :c:func:`uv_metrics_idle_time`.
+
+    - UV_LOOP_ENABLE_IO_URING_SQPOLL: Enable SQPOLL io_uring instance to handle
+      asynchronous file system operations.
+
+    .. versionchanged:: 1.39.0 added the UV_METRICS_IDLE_TIME option.
+
+    .. versionchanged:: 1.49.0 added the UV_LOOP_ENABLE_IO_URING_SQPOLL option.
+
+.. c:function:: int uv_loop_close(uv_loop_t* loop)
+
+    Releases all internal loop resources. Call this function only when the loop
+    has finished executing and all open handles and requests have been closed,
+    or it will return UV_EBUSY. After this function returns, the user can free
+    the memory allocated for the loop.
+
+.. c:function:: uv_loop_t* uv_default_loop(void)
+
+    Returns the initialized default loop. It may return NULL in case of
+    allocation failure.
+
+    This function is just a convenient way for having a global loop throughout
+    an application, the default loop is in no way different than the ones
+    initialized with :c:func:`uv_loop_init`. As such, the default loop can (and
+    should) be closed with :c:func:`uv_loop_close` so the resources associated
+    with it are freed.
+
+    .. warning::
+        This function is not thread safe.
+
+.. c:function:: int uv_run(uv_loop_t* loop, uv_run_mode mode)
+
+    This function runs the event loop. It will act differently depending on the
+    specified mode:
+
+    - UV_RUN_DEFAULT: Runs the event loop until there are no more active and
+      referenced handles or requests. Returns non-zero if :c:func:`uv_stop`
+      was called and there are still active handles or requests.  Returns
+      zero in all other cases.
+    - UV_RUN_ONCE: Poll for i/o once. Note that this function blocks if
+      there are no pending callbacks. Returns zero when done (no active handles
+      or requests left), or non-zero if more callbacks are expected (meaning
+      you should run the event loop again sometime in the future).
+    - UV_RUN_NOWAIT: Poll for i/o once but don't block if there are no
+      pending callbacks. Returns zero if done (no active handles
+      or requests left), or non-zero if more callbacks are expected (meaning
+      you should run the event loop again sometime in the future).
+
+    :c:func:`uv_run` is not reentrant. It must not be called from a callback.
+
+.. c:function:: int uv_loop_alive(const uv_loop_t* loop)
+
+    Returns non-zero if there are referenced active handles, active
+    requests or closing handles in the loop.
+
+.. c:function:: void uv_stop(uv_loop_t* loop)
+
+    Stop the event loop, causing :c:func:`uv_run` to end as soon as
+    possible. This will happen not sooner than the next loop iteration.
+    If this function was called before blocking for i/o, the loop won't block
+    for i/o on this iteration.
+
+.. c:function:: size_t uv_loop_size(void)
+
+    Returns the size of the `uv_loop_t` structure. Useful for FFI binding
+    writers who don't want to know the structure layout.
+
+.. c:function:: int uv_backend_fd(const uv_loop_t* loop)
+
+    Get backend file descriptor. Only kqueue, epoll and event ports are
+    supported.
+
+    This can be used in conjunction with `uv_run(loop, UV_RUN_NOWAIT)` to
+    poll in one thread and run the event loop's callbacks in another see
+    test/test-embed.c for an example.
+
+    .. note::
+        Embedding a kqueue fd in another kqueue pollset doesn't work on all platforms. It's not
+        an error to add the fd but it never generates events.
+
+.. c:function:: int uv_backend_timeout(const uv_loop_t* loop)
+
+    Get the poll timeout. The return value is in milliseconds, or -1 for no
+    timeout.
+
+.. c:function:: uint64_t uv_now(const uv_loop_t* loop)
+
+    Return the current timestamp in milliseconds. The timestamp is cached at
+    the start of the event loop tick, see :c:func:`uv_update_time` for details
+    and rationale.
+
+    The timestamp increases monotonically from some arbitrary point in time.
+    Don't make assumptions about the starting point, you will only get
+    disappointed.
+
+    .. note::
+        Use :c:func:`uv_hrtime` if you need sub-millisecond granularity.
+
+.. c:function:: void uv_update_time(uv_loop_t* loop)
+
+    Update the event loop's concept of "now". Libuv caches the current time
+    at the start of the event loop tick in order to reduce the number of
+    time-related system calls.
+
+    You won't normally need to call this function unless you have callbacks
+    that block the event loop for longer periods of time, where "longer" is
+    somewhat subjective but probably on the order of a millisecond or more.
+
+.. c:function:: void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg)
+
+    Walk the list of handles: `walk_cb` will be executed with the given `arg`.
+
+.. c:function:: int uv_loop_fork(uv_loop_t* loop)
+
+    .. versionadded:: 1.12.0
+
+    Reinitialize any kernel state necessary in the child process after
+    a :man:`fork(2)` system call.
+
+    Previously started watchers will continue to be started in the
+    child process.
+
+    It is necessary to explicitly call this function on every event
+    loop created in the parent process that you plan to continue to
+    use in the child, including the default loop (even if you don't
+    continue to use it in the parent). This function must be called
+    before calling :c:func:`uv_run` or any other API function using
+    the loop in the child. Failure to do so will result in undefined
+    behaviour, possibly including duplicate events delivered to both
+    parent and child or aborting the child process.
+
+    When possible, it is preferred to create a new loop in the child
+    process instead of reusing a loop created in the parent. New loops
+    created in the child process after the fork should not use this
+    function.
+
+    This function is not implemented on Windows, where it returns ``UV_ENOSYS``.
+
+    .. caution::
+
+       This function is experimental. It may contain bugs, and is subject to
+       change or removal. API and ABI stability is not guaranteed.
+
+    .. note::
+
+        On Mac OS X, if directory FS event handles were in use in the
+        parent process *for any event loop*, the child process will no
+        longer be able to use the most efficient FSEvent
+        implementation. Instead, uses of directory FS event handles in
+        the child will fall back to the same implementation used for
+        files and on other kqueue-based systems.
+
+    .. caution::
+
+       On AIX and SunOS, FS event handles that were already started in
+       the parent process at the time of forking will *not* deliver
+       events in the child process; they must be closed and restarted.
+       On all other platforms, they will continue to work normally
+       without any further intervention.
+
+    .. caution::
+
+       Any previous value returned from :c:func:`uv_backend_fd` is now
+       invalid. That function must be called again to determine the
+       correct backend file descriptor.
+
+.. c:function:: void* uv_loop_get_data(const uv_loop_t* loop)
+
+    Returns `loop->data`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: void uv_loop_set_data(uv_loop_t* loop, void* data)
+
+    Sets `loop->data` to `data`.
+
+    .. versionadded:: 1.19.0

deps/uv/docs/src/metrics.rst

@@ -0,0 +1,71 @@
+
+.. _metrics:
+
+Metrics operations
+======================
+
+libuv provides a metrics API to track various internal operations of the event
+loop.
+
+
+Data types
+----------
+
+.. c:type:: uv_metrics_t
+
+    The struct that contains event loop metrics. It is recommended to retrieve
+    these metrics in a :c:type:`uv_prepare_cb` in order to make sure there are
+    no inconsistencies with the metrics counters.
+
+    ::
+
+        typedef struct {
+            uint64_t loop_count;
+            uint64_t events;
+            uint64_t events_waiting;
+            /* private */
+            uint64_t* reserved[13];
+        } uv_metrics_t;
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: uint64_t uv_metrics_t.loop_count
+
+    Number of event loop iterations.
+
+.. c:member:: uint64_t uv_metrics_t.events
+
+    Number of events that have been processed by the event handler.
+
+.. c:member:: uint64_t uv_metrics_t.events_waiting
+
+    Number of events that were waiting to be processed when the event provider
+    was called.
+
+
+API
+---
+
+.. c:function:: uint64_t uv_metrics_idle_time(uv_loop_t* loop)
+
+    Retrieve the amount of time the event loop has been idle in the kernel's
+    event provider (e.g. ``epoll_wait``). The call is thread safe.
+
+    The return value is the accumulated time spent idle in the kernel's event
+    provider starting from when the :c:type:`uv_loop_t` was configured to
+    collect the idle time.
+
+    .. note::
+        The event loop will not begin accumulating the event provider's idle
+        time until calling :c:type:`uv_loop_configure` with
+        :c:type:`UV_METRICS_IDLE_TIME`.
+
+    .. versionadded:: 1.39.0
+
+.. c:function:: int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics)
+
+    Copy the current set of event loop metrics to the ``metrics`` pointer.
+
+    .. versionadded:: 1.45.0

deps/uv/docs/src/migration_010_100.rst

@@ -0,0 +1,244 @@
+
+.. _migration_010_100:
+
+libuv 0.10 -> 1.0.0 migration guide
+===================================
+
+Some APIs changed quite a bit throughout the 1.0.0 development process. Here
+is a migration guide for the most significant changes that happened after 0.10
+was released.
+
+
+Loop initialization and closing
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In libuv 0.10 (and previous versions), loops were created with `uv_loop_new`, which
+allocated memory for a new loop and initialized it; and destroyed with `uv_loop_delete`,
+which destroyed the loop and freed the memory. Starting with 1.0, those are deprecated
+and the user is responsible for allocating the memory and then initializing the loop.
+
+libuv 0.10
+
+::
+
+    uv_loop_t* loop = uv_loop_new();
+    ...
+    uv_loop_delete(loop);
+
+libuv 1.0
+
+::
+
+    uv_loop_t* loop = malloc(sizeof *loop);
+    uv_loop_init(loop);
+    ...
+    uv_loop_close(loop);
+    free(loop);
+
+.. note::
+    Error handling was omitted for brevity. Check the documentation for :c:func:`uv_loop_init`
+    and :c:func:`uv_loop_close`.
+
+
+Error handling
+~~~~~~~~~~~~~~
+
+Error handling had a major overhaul in libuv 1.0. In general, functions and status parameters
+would get 0 for success and -1 for failure on libuv 0.10, and the user had to use `uv_last_error`
+to fetch the error code, which was a positive number.
+
+In 1.0, functions and status parameters contain the actual error code, which is 0 for success, or
+a negative number in case of error.
+
+libuv 0.10
+
+::
+
+    ... assume 'server' is a TCP server which is already listening
+    r = uv_listen((uv_stream_t*) server, 511, NULL);
+    if (r == -1) {
+      uv_err_t err = uv_last_error(uv_default_loop());
+      /* err.code contains UV_EADDRINUSE */
+    }
+
+libuv 1.0
+
+::
+
+    ... assume 'server' is a TCP server which is already listening
+    r = uv_listen((uv_stream_t*) server, 511, NULL);
+    if (r < 0) {
+      /* r contains UV_EADDRINUSE */
+    }
+
+
+Threadpool changes
+~~~~~~~~~~~~~~~~~~
+
+In libuv 0.10 Unix used a threadpool which defaulted to 4 threads, while Windows used the
+`QueueUserWorkItem` API, which uses a Windows internal threadpool, which defaults to 512
+threads per process.
+
+In 1.0, we unified both implementations, so Windows now uses the same implementation Unix
+does. The threadpool size can be set by exporting the ``UV_THREADPOOL_SIZE`` environment
+variable. See :c:ref:`threadpool`.
+
+
+Allocation callback API change
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In libuv 0.10 the callback had to return a filled :c:type:`uv_buf_t` by value:
+
+::
+
+    uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
+        return uv_buf_init(malloc(size), size);
+    }
+
+In libuv 1.0 a pointer to a buffer is passed to the callback, which the user
+needs to fill:
+
+::
+
+    void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
+        buf->base = malloc(size);
+        buf->len = size;
+    }
+
+
+Unification of IPv4 / IPv6 APIs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+libuv 1.0 unified the IPv4 and IPv6 APIS. There is no longer a `uv_tcp_bind` and `uv_tcp_bind6`
+duality, there is only :c:func:`uv_tcp_bind` now.
+
+IPv4 functions took ``struct sockaddr_in`` structures by value, and IPv6 functions took
+``struct sockaddr_in6``. Now functions take a ``struct sockaddr*`` (note it's a pointer).
+It can be stack allocated.
+
+libuv 0.10
+
+::
+
+    struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", 1234);
+    ...
+    uv_tcp_bind(&server, addr)
+
+libuv 1.0
+
+::
+
+    struct sockaddr_in addr;
+    uv_ip4_addr("0.0.0.0", 1234, &addr)
+    ...
+    uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0);
+
+The IPv4 and IPv6 struct creating functions (:c:func:`uv_ip4_addr` and :c:func:`uv_ip6_addr`)
+have also changed, make sure you check the documentation.
+
+..note::
+    This change applies to all functions that made a distinction between IPv4 and IPv6
+    addresses.
+
+
+Streams / UDP  data receive callback API change
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The streams and UDP data receive callbacks now get a pointer to a :c:type:`uv_buf_t` buffer,
+not a structure by value.
+
+libuv 0.10
+
+::
+
+    void on_read(uv_stream_t* handle,
+                 ssize_t nread,
+                 uv_buf_t buf) {
+        ...
+    }
+
+    void recv_cb(uv_udp_t* handle,
+                 ssize_t nread,
+                 uv_buf_t buf,
+                 struct sockaddr* addr,
+                 unsigned flags) {
+        ...
+    }
+
+libuv 1.0
+
+::
+
+    void on_read(uv_stream_t* handle,
+                 ssize_t nread,
+                 const uv_buf_t* buf) {
+        ...
+    }
+
+    void recv_cb(uv_udp_t* handle,
+                 ssize_t nread,
+                 const uv_buf_t* buf,
+                 const struct sockaddr* addr,
+                 unsigned flags) {
+        ...
+    }
+
+
+Receiving handles over pipes API change
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In libuv 0.10 (and earlier versions) the `uv_read2_start` function was used to start reading
+data on a pipe, which could also result in the reception of handles over it. The callback
+for such function looked like this:
+
+::
+
+    void on_read(uv_pipe_t* pipe,
+                 ssize_t nread,
+                 uv_buf_t buf,
+                 uv_handle_type pending) {
+        ...
+    }
+
+In libuv 1.0, `uv_read2_start` was removed, and the user needs to check if there are pending
+handles using :c:func:`uv_pipe_pending_count` and :c:func:`uv_pipe_pending_type` while in
+the read callback:
+
+::
+
+    void on_read(uv_stream_t* handle,
+                 ssize_t nread,
+                 const uv_buf_t* buf) {
+        ...
+        while (uv_pipe_pending_count((uv_pipe_t*) handle) != 0) {
+            pending = uv_pipe_pending_type((uv_pipe_t*) handle);
+            ...
+        }
+        ...
+    }
+
+
+Extracting the file descriptor out of a handle
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+While it wasn't supported by the API, users often accessed the libuv internals in
+order to get access to the file descriptor of a TCP handle, for example.
+
+::
+
+    fd = handle->io_watcher.fd;
+
+This is now properly exposed through the :c:func:`uv_fileno` function.
+
+
+uv_fs_readdir rename and API change
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+`uv_fs_readdir` returned a list of strings in the `req->ptr` field upon completion in
+libuv 0.10. In 1.0, this function got renamed to :c:func:`uv_fs_scandir`, since it's
+actually implemented using ``scandir(3)``.
+
+In addition, instead of allocating a full list strings, the user is able to get one
+result at a time by using the :c:func:`uv_fs_scandir_next` function. This function
+does not need to make a roundtrip to the threadpool, because libuv will keep the
+list of *dents* returned by ``scandir(3)`` around.

deps/uv/docs/src/misc.rst

@@ -0,0 +1,940 @@
+
+.. _misc:
+
+Miscellaneous utilities
+=======================
+
+This section contains miscellaneous functions that don't really belong in any
+other section.
+
+
+Data types
+----------
+
+.. c:type:: uv_buf_t
+
+    Buffer data type.
+
+    .. c:member:: char* uv_buf_t.base
+
+        Pointer to the base of the buffer.
+
+    .. c:member:: size_t uv_buf_t.len
+
+        Total bytes in the buffer.
+
+        .. note::
+            On Windows this field is ULONG.
+
+.. c:type:: void* (*uv_malloc_func)(size_t size)
+
+        Replacement function for :man:`malloc(3)`.
+        See :c:func:`uv_replace_allocator`.
+
+.. c:type::  void* (*uv_realloc_func)(void* ptr, size_t size)
+
+        Replacement function for :man:`realloc(3)`.
+        See :c:func:`uv_replace_allocator`.
+
+.. c:type::  void* (*uv_calloc_func)(size_t count, size_t size)
+
+        Replacement function for :man:`calloc(3)`.
+        See :c:func:`uv_replace_allocator`.
+
+.. c:type:: void (*uv_free_func)(void* ptr)
+
+        Replacement function for :man:`free(3)`.
+        See :c:func:`uv_replace_allocator`.
+
+.. c:type::  void (*uv_random_cb)(uv_random_t* req, int status, void* buf, size_t buflen)
+
+    Callback passed to :c:func:`uv_random`. `status` is non-zero in case of
+    error. The `buf` pointer is the same pointer that was passed to
+    :c:func:`uv_random`.
+
+.. c:type:: uv_file
+
+    Cross platform representation of a file handle.
+
+.. c:type:: uv_os_sock_t
+
+    Cross platform representation of a socket handle.
+
+.. c:type:: uv_os_fd_t
+
+    Abstract representation of a file descriptor. On Unix systems this is a
+    `typedef` of `int` and on Windows a `HANDLE`.
+
+.. c:type:: uv_pid_t
+
+    Cross platform representation of a `pid_t`.
+
+    .. versionadded:: 1.16.0
+
+.. c:type:: uv_timeval_t
+
+    Y2K38-unsafe data type for storing times with microsecond resolution.
+    Will be replaced with :c:type:`uv_timeval64_t` in libuv v2.0.
+
+    ::
+
+        typedef struct {
+            long tv_sec;
+            long tv_usec;
+        } uv_timeval_t;
+
+.. c:type:: uv_timeval64_t
+
+    Y2K38-safe data type for storing times with microsecond resolution.
+
+    ::
+
+        typedef struct {
+            int64_t tv_sec;
+            int32_t tv_usec;
+        } uv_timeval64_t;
+
+.. c:type:: uv_timespec64_t
+
+    Y2K38-safe data type for storing times with nanosecond resolution.
+
+    ::
+
+        typedef struct {
+            int64_t tv_sec;
+            int32_t tv_nsec;
+        } uv_timespec64_t;
+
+.. c:enum:: uv_clock_id
+
+    Clock source for :c:func:`uv_clock_gettime`.
+
+    ::
+
+        typedef enum {
+          UV_CLOCK_MONOTONIC,
+          UV_CLOCK_REALTIME
+        } uv_clock_id;
+
+.. c:type:: uv_rusage_t
+
+    Data type for resource usage results.
+
+    ::
+
+        typedef struct {
+            uv_timeval_t ru_utime; /* user CPU time used */
+            uv_timeval_t ru_stime; /* system CPU time used */
+            uint64_t ru_maxrss; /* maximum resident set size */
+            uint64_t ru_ixrss; /* integral shared memory size (X) */
+            uint64_t ru_idrss; /* integral unshared data size (X) */
+            uint64_t ru_isrss; /* integral unshared stack size (X) */
+            uint64_t ru_minflt; /* page reclaims (soft page faults) (X) */
+            uint64_t ru_majflt; /* page faults (hard page faults) */
+            uint64_t ru_nswap; /* swaps (X) */
+            uint64_t ru_inblock; /* block input operations */
+            uint64_t ru_oublock; /* block output operations */
+            uint64_t ru_msgsnd; /* IPC messages sent (X) */
+            uint64_t ru_msgrcv; /* IPC messages received (X) */
+            uint64_t ru_nsignals; /* signals received (X) */
+            uint64_t ru_nvcsw; /* voluntary context switches (X) */
+            uint64_t ru_nivcsw; /* involuntary context switches (X) */
+        } uv_rusage_t;
+
+    Members marked with `(X)` are unsupported on Windows.
+    See :man:`getrusage(2)` for supported fields on UNIX-like platforms.
+
+    The maximum resident set size is reported in kilobytes, the unit most
+    platforms use natively.
+
+.. c:type:: uv_cpu_info_t
+
+    Data type for CPU information.
+
+    ::
+
+        typedef struct uv_cpu_info_s {
+            char* model;
+            int speed;
+            struct uv_cpu_times_s {
+                uint64_t user; /* milliseconds */
+                uint64_t nice; /* milliseconds */
+                uint64_t sys; /* milliseconds */
+                uint64_t idle; /* milliseconds */
+                uint64_t irq; /* milliseconds */
+            } cpu_times;
+        } uv_cpu_info_t;
+
+.. c:type:: uv_interface_address_t
+
+    Data type for interface addresses.
+
+    ::
+
+        typedef struct uv_interface_address_s {
+            char* name;
+            char phys_addr[6];
+            int is_internal;
+            union {
+                struct sockaddr_in address4;
+                struct sockaddr_in6 address6;
+            } address;
+            union {
+                struct sockaddr_in netmask4;
+                struct sockaddr_in6 netmask6;
+            } netmask;
+        } uv_interface_address_t;
+
+.. c:type:: uv_passwd_t
+
+    Data type for password file information.
+
+    ::
+
+        typedef struct uv_passwd_s {
+            char* username;
+            long uid;
+            long gid;
+            char* shell;
+            char* homedir;
+        } uv_passwd_t;
+
+.. c:type:: uv_group_t
+
+    Data type for group file information.
+
+    ::
+
+        typedef struct uv_group_s {
+          char* groupname;
+          unsigned long gid;
+          char** members;
+        } uv_group_t;
+
+.. c:type:: uv_utsname_t
+
+    Data type for operating system name and version information.
+
+    ::
+
+        typedef struct uv_utsname_s {
+            char sysname[256];
+            char release[256];
+            char version[256];
+            char machine[256];
+        } uv_utsname_t;
+
+.. c:type:: uv_env_item_t
+
+    Data type for environment variable storage.
+
+    ::
+
+        typedef struct uv_env_item_s {
+            char* name;
+            char* value;
+        } uv_env_item_t;
+
+.. c:type:: uv_random_t
+
+    Random data request type.
+
+API
+---
+
+.. c:function:: uv_handle_type uv_guess_handle(uv_file file)
+
+    Used to detect what type of stream should be used with a given file
+    descriptor. Usually this will be used during initialization to guess the
+    type of the stdio streams.
+
+    For :man:`isatty(3)` equivalent functionality use this function and test
+    for `UV_TTY`.
+
+.. c:function:: int uv_replace_allocator(uv_malloc_func malloc_func, uv_realloc_func realloc_func, uv_calloc_func calloc_func, uv_free_func free_func)
+
+    .. versionadded:: 1.6.0
+
+    Override the use of the standard library's :man:`malloc(3)`,
+    :man:`calloc(3)`, :man:`realloc(3)`, :man:`free(3)`, memory allocation
+    functions.
+
+    This function must be called before any other libuv function is called or
+    after all resources have been freed and thus libuv doesn't reference
+    any allocated memory chunk.
+
+    On success, it returns 0, if any of the function pointers is `NULL` it
+    returns `UV_EINVAL`.
+
+    .. warning:: There is no protection against changing the allocator multiple
+                 times. If the user changes it they are responsible for making
+                 sure the allocator is changed while no memory was allocated with
+                 the previous allocator, or that they are compatible.
+
+    .. warning:: Allocator must be thread-safe.
+
+.. c:function:: void uv_library_shutdown(void);
+
+    .. versionadded:: 1.38.0
+
+    Release any global state that libuv is holding onto. Libuv will normally
+    do so automatically when it is unloaded but it can be instructed to perform
+    cleanup manually.
+
+    .. warning:: Only call :c:func:`uv_library_shutdown()` once.
+
+    .. warning:: Don't call :c:func:`uv_library_shutdown()` when there are
+                 still event loops or I/O requests active.
+
+    .. warning:: Don't call libuv functions after calling
+                 :c:func:`uv_library_shutdown()`.
+
+.. c:function:: uv_buf_t uv_buf_init(char* base, unsigned int len)
+
+    Constructor for :c:type:`uv_buf_t`.
+
+    Due to platform differences the user cannot rely on the ordering of the
+    `base` and `len` members of the uv_buf_t struct. The user is responsible for
+    freeing `base` after the uv_buf_t is done. Return struct passed by value.
+
+.. c:function:: char** uv_setup_args(int argc, char** argv)
+
+    Store the program arguments. Required for getting / setting the process title
+    or the executable path. Libuv may take ownership of the memory that `argv` 
+    points to. This function should be called exactly once, at program start-up.
+
+    Example:
+
+    ::
+
+        argv = uv_setup_args(argc, argv);  /* May return a copy of argv. */
+
+
+.. c:function:: int uv_get_process_title(char* buffer, size_t size)
+
+    Gets the title of the current process. You *must* call `uv_setup_args`
+    before calling this function on Unix and AIX systems. If `uv_setup_args`
+    has not been called on systems that require it, then `UV_ENOBUFS` is
+    returned. If `buffer` is `NULL` or `size` is zero, `UV_EINVAL` is returned.
+    If `size` cannot accommodate the process title and terminating `nul`
+    character, the function returns `UV_ENOBUFS`.
+
+    .. note::
+        On BSD systems, `uv_setup_args` is needed for getting the initial process
+        title. The process title returned will be an empty string until either
+        `uv_setup_args` or `uv_set_process_title` is called.
+
+    .. versionchanged:: 1.18.1 now thread-safe on all supported platforms.
+
+    .. versionchanged:: 1.39.0 now returns an error if `uv_setup_args` is needed
+                        but hasn't been called.
+
+.. c:function:: int uv_set_process_title(const char* title)
+
+    Sets the current process title. You *must* call `uv_setup_args` before
+    calling this function on Unix and AIX systems. If `uv_setup_args` has not
+    been called on systems that require it, then `UV_ENOBUFS` is returned. On
+    platforms with a fixed size buffer for the process title the contents of
+    `title` will be copied to the buffer and truncated if larger than the
+    available space. Other platforms will return `UV_ENOMEM` if they cannot
+    allocate enough space to duplicate the contents of `title`.
+
+    .. versionchanged:: 1.18.1 now thread-safe on all supported platforms.
+
+    .. versionchanged:: 1.39.0 now returns an error if `uv_setup_args` is needed
+                        but hasn't been called.
+
+.. c:function:: int uv_resident_set_memory(size_t* rss)
+
+    Gets the resident set size (RSS) for the current process.
+
+.. c:function:: int uv_uptime(double* uptime)
+
+    Gets the current system uptime. Depending on the system full or fractional seconds are returned.
+
+.. c:function:: int uv_getrusage(uv_rusage_t* rusage)
+
+    Gets the resource usage measures for the current process.
+
+    .. note::
+        On Windows not all fields are set, the unsupported fields are filled with zeroes.
+        See :c:type:`uv_rusage_t` for more details.
+
+.. c:function:: int uv_getrusage_thread(uv_rusage_t* rusage)
+
+    Gets the resource usage measures for the calling thread.
+
+    .. versionadded:: 1.50.0
+
+    .. note::
+        Not supported on all platforms. May return `UV_ENOTSUP`.
+        On macOS and Windows not all fields are set, the unsupported fields are filled with zeroes.
+        See :c:type:`uv_rusage_t` for more details.
+
+.. c:function:: uv_pid_t uv_os_getpid(void)
+
+    Returns the current process ID.
+
+    .. versionadded:: 1.18.0
+
+.. c:function:: uv_pid_t uv_os_getppid(void)
+
+    Returns the parent process ID.
+
+    .. versionadded:: 1.16.0
+
+.. c:function:: unsigned int uv_available_parallelism(void)
+
+    Returns an estimate of the default amount of parallelism a program should
+    use. Always returns a non-zero value.
+
+    On Linux, inspects the calling thread's CPU affinity mask to determine if
+    it has been pinned to specific CPUs.
+
+    On Windows, the available parallelism may be underreported on systems with
+    more than 64 logical CPUs.
+
+    On other platforms, reports the number of CPUs that the operating system
+    considers to be online.
+
+    .. versionadded:: 1.44.0
+
+.. c:function:: int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count)
+
+    Gets information about the CPUs on the system. The `cpu_infos` array will
+    have `count` elements and needs to be freed with :c:func:`uv_free_cpu_info`.
+
+    Use :c:func:`uv_available_parallelism` if you need to know how many CPUs
+    are available for threads or child processes.
+
+.. c:function:: void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count)
+
+    Frees the `cpu_infos` array previously allocated with :c:func:`uv_cpu_info`.
+
+.. c:function:: int uv_cpumask_size(void)
+
+    Returns the maximum size of the mask used for process/thread affinities,
+    or `UV_ENOTSUP` if affinities are not supported on the current platform.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: int uv_interface_addresses(uv_interface_address_t** addresses, int* count)
+
+    Gets address information about the network interfaces on the system. An
+    array of `count` elements is allocated and returned in `addresses`. It must
+    be freed by the user, calling :c:func:`uv_free_interface_addresses`.
+
+.. c:function:: void uv_free_interface_addresses(uv_interface_address_t* addresses, int count)
+
+    Free an array of :c:type:`uv_interface_address_t` which was returned by
+    :c:func:`uv_interface_addresses`.
+
+.. c:function:: void uv_loadavg(double avg[3])
+
+    Gets the load average. See: `<https://en.wikipedia.org/wiki/Load_(computing)>`_
+
+    .. note::
+        Returns [0,0,0] on Windows (i.e., it's not implemented).
+
+.. c:function:: int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr)
+
+    Convert a string containing an IPv4 addresses to a binary structure.
+
+.. c:function:: int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr)
+
+    Convert a string containing an IPv6 addresses to a binary structure.
+
+.. c:function:: int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size)
+
+    Convert a binary structure containing an IPv4 address to a string.
+
+.. c:function:: int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size)
+
+    Convert a binary structure containing an IPv6 address to a string.
+
+.. c:function:: int uv_ip_name(const struct sockaddr *src, char *dst, size_t size)
+
+    Convert a binary structure containing an IPv4 address or an IPv6 address to a string.
+
+.. c:function:: int uv_inet_ntop(int af, const void* src, char* dst, size_t size)
+.. c:function:: int uv_inet_pton(int af, const char* src, void* dst)
+
+    Cross-platform IPv6-capable implementation of :man:`inet_ntop(3)`
+    and :man:`inet_pton(3)`. On success they return 0. In case of error
+    the target `dst` pointer is unmodified.
+
+.. c:macro:: UV_IF_NAMESIZE
+
+    Maximum IPv6 interface identifier name length.  Defined as
+    `IFNAMSIZ` on Unix and `IF_NAMESIZE` on Linux and Windows.
+
+    .. versionadded:: 1.16.0
+
+.. c:function:: int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size)
+
+    IPv6-capable implementation of :man:`if_indextoname(3)`. When called,
+    `*size` indicates the length of the `buffer`, which is used to store the
+    result.
+    On success, zero is returned, `buffer` contains the interface name, and
+    `*size` represents the string length of the `buffer`, excluding the NUL
+    terminator byte from `*size`. On error, a negative result is
+    returned. If `buffer` is not large enough to hold the result,
+    `UV_ENOBUFS` is returned, and `*size` represents the necessary size in
+    bytes, including the NUL terminator byte into the `*size`.
+
+    On Unix, the returned interface name can be used directly as an
+    interface identifier in scoped IPv6 addresses, e.g.
+    `fe80::abc:def1:2345%en0`.
+
+    On Windows, the returned interface cannot be used as an interface
+    identifier, as Windows uses numerical interface identifiers, e.g.
+    `fe80::abc:def1:2345%5`.
+
+    To get an interface identifier in a cross-platform compatible way,
+    use `uv_if_indextoiid()`.
+
+    Example:
+
+    ::
+
+        char ifname[UV_IF_NAMESIZE];
+        size_t size = sizeof(ifname);
+        uv_if_indextoname(sin6->sin6_scope_id, ifname, &size);
+
+    .. versionadded:: 1.16.0
+
+.. c:function:: int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size)
+
+    Retrieves a network interface identifier suitable for use in an IPv6 scoped
+    address. On Windows, returns the numeric `ifindex` as a string. On all other
+    platforms, `uv_if_indextoname()` is called. The result is written to
+    `buffer`, with `*size` indicating the length of `buffer`. If `buffer` is not
+    large enough to hold the result, then `UV_ENOBUFS` is returned, and `*size`
+    represents the size, including the NUL byte, required to hold the
+    result.
+
+    See `uv_if_indextoname` for further details.
+
+    .. versionadded:: 1.16.0
+
+.. c:function:: int uv_exepath(char* buffer, size_t* size)
+
+    Gets the executable path. You *must* call `uv_setup_args` before calling
+    this function.
+
+.. c:function:: int uv_cwd(char* buffer, size_t* size)
+
+    Gets the current working directory, and stores it in `buffer`. If the
+    current working directory is too large to fit in `buffer`, this function
+    returns `UV_ENOBUFS`, and sets `size` to the required length, including the
+    null terminator.
+
+    .. versionchanged:: 1.1.0
+
+        On Unix the path no longer ends in a slash.
+
+    .. versionchanged:: 1.9.0 the returned length includes the terminating null
+                        byte on `UV_ENOBUFS`, and the buffer is null terminated
+                        on success.
+
+
+.. c:function:: int uv_chdir(const char* dir)
+
+    Changes the current working directory.
+
+.. c:function:: int uv_os_homedir(char* buffer, size_t* size)
+
+    Gets the current user's home directory. On Windows, `uv_os_homedir()` first
+    checks the `USERPROFILE` environment variable using
+    `GetEnvironmentVariableW()`. If `USERPROFILE` is not set,
+    `GetUserProfileDirectoryW()` is called. On all other operating systems,
+    `uv_os_homedir()` first checks the `HOME` environment variable using
+    :man:`getenv(3)`. If `HOME` is not set, :man:`getpwuid_r(3)` is called. The
+    user's home directory is stored in `buffer`. When `uv_os_homedir()` is
+    called, `size` indicates the maximum size of `buffer`. On success `size` is set
+    to the string length of `buffer`. On `UV_ENOBUFS` failure `size` is set to the
+    required length for `buffer`, including the null byte.
+
+    .. warning::
+        `uv_os_homedir()` is not thread safe.
+
+    .. versionadded:: 1.6.0
+
+.. c:function:: int uv_os_tmpdir(char* buffer, size_t* size)
+
+    Gets the temp directory. On Windows, `uv_os_tmpdir()` uses `GetTempPathW()`.
+    On all other operating systems, `uv_os_tmpdir()` uses the first environment
+    variable found in the ordered list `TMPDIR`, `TMP`, `TEMP`, and `TEMPDIR`.
+    If none of these are found, the path `"/tmp"` is used, or, on Android,
+    `"/data/local/tmp"` is used. The temp directory is stored in `buffer`. When
+    `uv_os_tmpdir()` is called, `size` indicates the maximum size of `buffer`.
+    On success `size` is set to the string length of `buffer` (which does not
+    include the terminating null). On `UV_ENOBUFS` failure `size` is set to the
+    required length for `buffer`, including the null byte.
+
+    .. warning::
+        `uv_os_tmpdir()` is not thread safe.
+
+    .. versionadded:: 1.9.0
+
+.. c:function:: int uv_os_get_passwd(uv_passwd_t* pwd)
+
+    Gets a subset of the password file entry for the current effective uid (not
+    the real uid). The populated data includes the username, euid, gid, shell,
+    and home directory. On non-Windows systems, all data comes from
+    :man:`getpwuid_r(3)`. On Windows, uid and gid are set to -1 and have no
+    meaning, and shell is `NULL`. After successfully calling this function, the
+    memory allocated to `pwd` needs to be freed with
+    :c:func:`uv_os_free_passwd`.
+
+    .. versionadded:: 1.9.0
+
+.. c:function:: int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid)
+
+    Gets a subset of the password file entry for the provided uid.
+    The populated data includes the username, euid, gid, shell,
+    and home directory. On non-Windows systems, all data comes from
+    :man:`getpwuid_r(3)`. On Windows, uid and gid are set to -1 and have no
+    meaning, and shell is `NULL`. After successfully calling this function, the
+    memory allocated to `pwd` needs to be freed with
+    :c:func:`uv_os_free_passwd`.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: int uv_os_get_group(uv_group_t* group, uv_uid_t gid)
+
+    Gets a subset of the group file entry for the provided uid.
+    The populated data includes the group name, gid, and members. On non-Windows
+    systems, all data comes from :man:`getgrgid_r(3)`. On Windows, uid and gid
+    are set to -1 and have no meaning. After successfully calling this function,
+    the memory allocated to `group` needs to be freed with
+    :c:func:`uv_os_free_group`.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: void uv_os_free_group(uv_passwd_t* pwd)
+
+    Frees the memory previously allocated with :c:func:`uv_os_get_group`.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: void uv_os_free_passwd(uv_passwd_t* pwd)
+
+    Frees the `pwd` memory previously allocated with :c:func:`uv_os_get_passwd`.
+
+    .. versionadded:: 1.9.0
+
+.. c:function:: uint64_t uv_get_free_memory(void)
+
+    Gets the amount of free memory available in the system, as reported by
+    the kernel (in bytes). Returns 0 when unknown.
+
+.. c:function:: uint64_t uv_get_total_memory(void)
+
+    Gets the total amount of physical memory in the system (in bytes).
+    Returns 0 when unknown.
+
+.. c:function:: uint64_t uv_get_constrained_memory(void)
+
+    Gets the total amount of memory available to the process (in bytes) based on
+    limits imposed by the OS. If there is no such constraint, or the constraint
+    is unknown, `0` is returned. If there is a constraining mechanism, but there
+    is no constraint set, `UINT64_MAX` is returned. Note that it is not unusual
+    for this value to be less than or greater than :c:func:`uv_get_total_memory`.
+
+    .. note::
+        This function currently only returns a non-zero value on Linux, based
+        on cgroups if it is present, and on z/OS based on RLIMIT_MEMLIMIT.
+
+    .. versionadded:: 1.29.0
+
+.. c:function:: uint64_t uv_get_available_memory(void)
+
+    Gets the amount of free memory that is still available to the process (in bytes).
+    This differs from :c:func:`uv_get_free_memory` in that it takes into account any
+    limits imposed by the OS. If there is no such constraint, or the constraint
+    is unknown, the amount returned will be identical to :c:func:`uv_get_free_memory`.
+
+    .. note::
+        This function currently only returns a value that is different from
+        what :c:func:`uv_get_free_memory` reports on Linux, based
+        on cgroups if it is present.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: uint64_t uv_hrtime(void)
+
+    Returns the current high-resolution timestamp. This is expressed in
+    nanoseconds. It is relative to an arbitrary time in the past. It is not
+    related to the time of day and therefore not subject to clock drift. The
+    primary use is for measuring performance between intervals.
+
+    .. note::
+        Not every platform can support nanosecond resolution; however, this value will always
+        be in nanoseconds.
+
+.. c:function:: int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts)
+
+    Obtain the current system time from a high-resolution real-time or monotonic
+    clock source.
+
+    The real-time clock counts from the UNIX epoch (1970-01-01) and is subject
+    to time adjustments; it can jump back in time.
+
+    The monotonic clock counts from an arbitrary point in the past and never
+    jumps back in time.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: void uv_print_all_handles(uv_loop_t* loop, FILE* stream)
+
+    Prints all handles associated with the given `loop` to the given `stream`.
+
+    Example:
+
+    ::
+
+        uv_print_all_handles(uv_default_loop(), stderr);
+        /*
+        [--I] signal   0x1a25ea8
+        [-AI] async    0x1a25cf0
+        [R--] idle     0x1a7a8c8
+        */
+
+    The format is `[flags] handle-type handle-address`. For `flags`:
+
+    - `R` is printed for a handle that is referenced
+    - `A` is printed for a handle that is active
+    - `I` is printed for a handle that is internal
+
+    .. warning::
+        This function is meant for ad hoc debugging, there is no API/ABI
+        stability guarantees.
+
+    .. versionadded:: 1.8.0
+
+.. c:function:: void uv_print_active_handles(uv_loop_t* loop, FILE* stream)
+
+    This is the same as :c:func:`uv_print_all_handles` except only active handles
+    are printed.
+
+    .. warning::
+        This function is meant for ad hoc debugging, there is no API/ABI
+        stability guarantees.
+
+    .. versionadded:: 1.8.0
+
+.. c:function:: int uv_os_environ(uv_env_item_t** envitems, int* count)
+
+    Retrieves all environment variables. This function will allocate memory
+    which must be freed by calling :c:func:`uv_os_free_environ`.
+
+    .. warning::
+        This function is not thread safe.
+
+    .. versionadded:: 1.31.0
+
+.. c:function:: void uv_os_free_environ(uv_env_item_t* envitems, int count);
+
+    Frees the memory allocated for the environment variables by
+    :c:func:`uv_os_environ`.
+
+    .. versionadded:: 1.31.0
+
+.. c:function:: int uv_os_getenv(const char* name, char* buffer, size_t* size)
+
+    Retrieves the environment variable specified by `name`, copies its value
+    into `buffer`, and sets `size` to the string length of the value. When
+    calling this function, `size` must be set to the amount of storage available
+    in `buffer`, including the null terminator. If the environment variable
+    exceeds the storage available in `buffer`, `UV_ENOBUFS` is returned, and
+    `size` is set to the amount of storage required to hold the value. If no
+    matching environment variable exists, `UV_ENOENT` is returned.
+
+    .. warning::
+        This function is not thread safe.
+
+    .. versionadded:: 1.12.0
+
+.. c:function:: int uv_os_setenv(const char* name, const char* value)
+
+    Creates or updates the environment variable specified by `name` with
+    `value`.
+
+    .. warning::
+        This function is not thread safe.
+
+    .. versionadded:: 1.12.0
+
+.. c:function:: int uv_os_unsetenv(const char* name)
+
+    Deletes the environment variable specified by `name`. If no such environment
+    variable exists, this function returns successfully.
+
+    .. warning::
+        This function is not thread safe.
+
+    .. versionadded:: 1.12.0
+
+.. c:function:: int uv_os_gethostname(char* buffer, size_t* size)
+
+    Returns the hostname as a null-terminated string in `buffer`, and sets
+    `size` to the string length of the hostname. When calling this function,
+    `size` must be set to the amount of storage available in `buffer`, including
+    the null terminator. If the hostname exceeds the storage available in
+    `buffer`, `UV_ENOBUFS` is returned, and `size` is set to the amount of
+    storage required to hold the value.
+
+    .. versionadded:: 1.12.0
+
+    .. versionchanged:: 1.26.0 `UV_MAXHOSTNAMESIZE` is available and represents
+                               the maximum `buffer` size required to store a
+                               hostname and terminating `nul` character.
+
+.. c:function:: int uv_os_getpriority(uv_pid_t pid, int* priority)
+
+    Retrieves the scheduling priority of the process specified by `pid`. The
+    returned value of `priority` is between -20 (high priority) and 19 (low
+    priority).
+
+    .. note::
+        On Windows, the returned priority will equal one of the `UV_PRIORITY`
+        constants.
+
+    .. versionadded:: 1.23.0
+
+.. c:function:: int uv_os_setpriority(uv_pid_t pid, int priority)
+
+    Sets the scheduling priority of the process specified by `pid`. The
+    `priority` value range is between -20 (high priority) and 19 (low priority).
+    The constants `UV_PRIORITY_LOW`, `UV_PRIORITY_BELOW_NORMAL`,
+    `UV_PRIORITY_NORMAL`, `UV_PRIORITY_ABOVE_NORMAL`, `UV_PRIORITY_HIGH`, and
+    `UV_PRIORITY_HIGHEST` are also provided for convenience.
+
+    .. note::
+        On Windows, this function utilizes `SetPriorityClass()`. The `priority`
+        argument is mapped to a Windows priority class. When retrieving the
+        process priority, the result will equal one of the `UV_PRIORITY`
+        constants, and not necessarily the exact value of `priority`.
+
+    .. note::
+        On Windows, setting `PRIORITY_HIGHEST` will only work for elevated user,
+        for others it will be silently reduced to `PRIORITY_HIGH`.
+
+    .. note::
+        On IBM i PASE, the highest process priority is -10. The constant
+        `UV_PRIORITY_HIGHEST` is -10, `UV_PRIORITY_HIGH` is -7, 
+        `UV_PRIORITY_ABOVE_NORMAL` is -4, `UV_PRIORITY_NORMAL` is 0,
+        `UV_PRIORITY_BELOW_NORMAL` is 15 and `UV_PRIORITY_LOW` is 39.
+
+    .. note::
+        On IBM i PASE, you are not allowed to change your priority unless you
+        have the \*JOBCTL special authority (even to lower it).
+
+    .. versionadded:: 1.23.0
+
+.. c:function:: int uv_os_uname(uv_utsname_t* buffer)
+
+    Retrieves system information in `buffer`. The populated data includes the
+    operating system name, release, version, and machine. On non-Windows
+    systems, `uv_os_uname()` is a thin wrapper around :man:`uname(2)`. Returns
+    zero on success, and a non-zero error value otherwise.
+
+    .. versionadded:: 1.25.0
+
+.. c:function:: int uv_gettimeofday(uv_timeval64_t* tv)
+
+    Cross-platform implementation of :man:`gettimeofday(2)`. The timezone
+    argument to `gettimeofday()` is not supported, as it is considered obsolete.
+
+    .. versionadded:: 1.28.0
+
+.. c:function:: int uv_random(uv_loop_t* loop, uv_random_t* req, void* buf, size_t buflen, unsigned int flags, uv_random_cb cb)
+
+    Fill `buf` with exactly `buflen` cryptographically strong random bytes
+    acquired from the system CSPRNG. `flags` is reserved for future extension
+    and must currently be 0.
+
+    Short reads are not possible. When less than `buflen` random bytes are
+    available, a non-zero error value is returned or passed to the callback.
+
+    The synchronous version may block indefinitely when not enough entropy
+    is available. The asynchronous version may not ever finish when the system
+    is low on entropy.
+
+    Sources of entropy:
+
+    - Windows: `RtlGenRandom <https://docs.microsoft.com/en-us/windows/desktop/api/ntsecapi/nf-ntsecapi-rtlgenrandom>_`.
+    - Linux, Android: :man:`getrandom(2)` if available, or :man:`urandom(4)`
+      after reading from `/dev/random` once, or the `KERN_RANDOM`
+      :man:`sysctl(2)`.
+    - FreeBSD: `getrandom(2) <https://www.freebsd.org/cgi/man.cgi?query=getrandom&sektion=2>_`,
+      or `/dev/urandom` after reading from `/dev/random` once.
+    - NetBSD: `KERN_ARND` `sysctl(7) <https://man.netbsd.org/sysctl.7>_`
+    - macOS, OpenBSD: `getentropy(2) <https://man.openbsd.org/getentropy.2>_`
+      if available, or `/dev/urandom` after reading from `/dev/random` once.
+    - AIX: `/dev/random`.
+    - IBM i: `/dev/urandom`.
+    - Other UNIX: `/dev/urandom` after reading from `/dev/random` once.
+
+    :returns: 0 on success, or an error code < 0 on failure. The contents of
+        `buf` is undefined after an error.
+
+    .. note::
+        When using the synchronous version, both `loop` and `req` parameters
+        are not used and can be set to `NULL`.
+
+    .. versionadded:: 1.33.0
+
+.. c:function:: void uv_sleep(unsigned int msec)
+
+    Causes the calling thread to sleep for `msec` milliseconds.
+
+    .. versionadded:: 1.34.0
+
+String manipulation functions
+-----------------------------
+
+These string utilities are needed internally for dealing with Windows, and are
+exported to allow clients to work uniformly with this data when the libuv API
+is not complete.
+
+.. c:function:: size_t uv_utf16_length_as_wtf8(const uint16_t* utf16, ssize_t utf16_len)
+
+    Get the length of a UTF-16 (or UCS-2) `utf16` value after converting it to
+    WTF-8. If `utf16` is NUL terminated, `utf16_len` can be set to -1,
+    otherwise it must be specified.
+
+    .. versionadded:: 1.47.0
+
+.. c:function:: int uv_utf16_to_wtf8(const uint16_t* utf16, ssize_t utf16_len, char** wtf8_ptr, size_t* wtf8_len_ptr)
+
+    Convert UTF-16 (or UCS-2) data in `utf16` to WTF-8 data in `*wtf8_ptr`. The
+    `utf16_len` count (in characters) gives the length of `utf16`. If `utf16`
+    is NUL terminated, `utf16_len` can be set to -1, otherwise it must be
+    specified. If `wtf8_ptr` is `NULL`, no result will be computed, but the
+    length (equal to `uv_utf16_length_as_wtf8`) will be stored in `wtf8_ptr`.
+    If `*wtf8_ptr` is `NULL`, space for the conversion will be allocated and
+    returned in `wtf8_ptr` and the length will be returned in `wtf8_len_ptr`.
+    Otherwise, the length of `*wtf8_ptr` must be passed in `wtf8_len_ptr`. The
+    `wtf8_ptr` must contain an extra space for an extra NUL after the result.
+    If the result is truncated, `UV_ENOBUFS` will be returned and
+    `wtf8_len_ptr` will be the length of the required `wtf8_ptr` to contain the
+    whole result.
+
+    .. versionadded:: 1.47.0
+
+.. c:function:: ssize_t uv_wtf8_length_as_utf16(const char* wtf8)
+
+    Get the length in characters of a NUL-terminated WTF-8 `wtf8` value
+    after converting it to UTF-16 (or UCS-2), including NUL terminator.
+
+    .. versionadded:: 1.47.0
+
+.. c:function:: void uv_wtf8_to_utf16(const char* utf8, uint16_t* utf16, size_t utf16_len)
+
+    Convert NUL-terminated WTF-8 data in `wtf8` to UTF-16 (or UCS-2) data
+    in `utf16`. The `utf16_len` count (in characters) must include space
+    for the NUL terminator.
+
+    .. versionadded:: 1.47.0

deps/uv/docs/src/pipe.rst

@@ -0,0 +1,182 @@
+
+.. _pipe:
+
+:c:type:`uv_pipe_t` --- Pipe handle
+===================================
+
+Pipe handles provide an abstraction over streaming files on Unix (including
+local domain sockets, pipes, and FIFOs) and named pipes on Windows.
+
+:c:type:`uv_pipe_t` is a 'subclass' of :c:type:`uv_stream_t`.
+
+
+Data types
+----------
+
+.. c:type:: uv_pipe_t
+
+    Pipe handle type.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: int uv_pipe_t.ipc
+
+    Whether this pipe is suitable for handle passing between processes.
+    Only a connected pipe that will be passing the handles should have this flag
+    set, not the listening pipe that uv_accept is called on.
+
+.. seealso:: The :c:type:`uv_stream_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc)
+
+    Initialize a pipe handle. The `ipc` argument is a boolean to indicate if
+    this pipe will be used for handle passing between processes (which may
+    change the bytes on the wire). Only a connected pipe that will be
+    passing the handles should have this flag set, not the listening pipe
+    that uv_accept is called on.
+
+.. c:function:: int uv_pipe_open(uv_pipe_t* handle, uv_file file)
+
+    Open an existing file descriptor or HANDLE as a pipe.
+
+    .. versionchanged:: 1.2.1 the file descriptor is set to non-blocking mode.
+
+    .. note::
+        The passed file descriptor or HANDLE is not checked for its type, but
+        it's required that it represents a valid pipe.
+
+.. c:function:: int uv_pipe_bind(uv_pipe_t* handle, const char* name)
+
+    Bind the pipe to a file path (Unix) or a name (Windows).
+
+    Does not support Linux abstract namespace sockets,
+    unlike :c:func:`uv_pipe_bind2`.
+
+    Alias for ``uv_pipe_bind2(handle, name, strlen(name), 0)``.
+
+    .. note::
+        Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes,
+        typically between 92 and 108 bytes.
+
+.. c:function:: int uv_pipe_bind2(uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags)
+
+    Bind the pipe to a file path (Unix) or a name (Windows).
+
+    ``flags`` must be zero or ``UV_PIPE_NO_TRUNCATE``. Returns ``UV_EINVAL``
+    for unsupported flags without performing the bind operation.
+
+    Supports Linux abstract namespace sockets. ``namelen`` must include
+    the leading nul byte but not the trailing nul byte.
+
+    .. versionadded:: 1.46.0
+
+    .. note::
+        Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes,
+        typically between 92 and 108 bytes, unless the ``UV_PIPE_NO_TRUNCATE``
+        flag is specified, in which case an ``UV_EINVAL`` error is returned.
+
+.. c:function:: void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb)
+
+    Connect to the Unix domain socket or the Windows named pipe.
+
+    Does not support Linux abstract namespace sockets,
+    unlike :c:func:`uv_pipe_connect2`.
+
+    Alias for ``uv_pipe_connect2(req, handle, name, strlen(name), 0, cb)``.
+
+    .. note::
+        Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes,
+        typically between 92 and 108 bytes.
+
+.. c:function:: void uv_pipe_connect2(uv_connect_t* req, uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags, uv_connect_cb cb)
+
+    Connect to the Unix domain socket or the Windows named pipe.
+
+    ``flags`` must be zero or ``UV_PIPE_NO_TRUNCATE``. Returns ``UV_EINVAL``
+    for unsupported flags without performing the connect operation.
+
+    Supports Linux abstract namespace sockets. ``namelen`` must include
+    the leading nul byte but not the trailing nul byte.
+
+    .. versionadded:: 1.46.0
+
+    .. note::
+        Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes,
+        typically between 92 and 108 bytes, unless the ``UV_PIPE_NO_TRUNCATE``
+        flag is specified, in which case an ``UV_EINVAL`` error is returned.
+
+.. c:function:: int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size)
+
+    Get the name of the Unix domain socket or the named pipe.
+
+    A preallocated buffer must be provided. The size parameter holds the length
+    of the buffer and it's set to the number of bytes written to the buffer on
+    output. If the buffer is not big enough ``UV_ENOBUFS`` will be returned and
+    len will contain the required size.
+
+    .. versionchanged:: 1.3.0 the returned length no longer includes the terminating null byte,
+                        and the buffer is not null terminated.
+
+.. c:function:: int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size)
+
+    Get the name of the Unix domain socket or the named pipe to which the handle
+    is connected.
+
+    A preallocated buffer must be provided. The size parameter holds the length
+    of the buffer and it's set to the number of bytes written to the buffer on
+    output. If the buffer is not big enough ``UV_ENOBUFS`` will be returned and
+    len will contain the required size.
+
+    .. versionadded:: 1.3.0
+
+.. c:function:: void uv_pipe_pending_instances(uv_pipe_t* handle, int count)
+
+    Set the number of pending pipe instance handles when the pipe server is
+    waiting for connections.
+
+    .. note::
+        This setting applies to Windows only.
+
+.. c:function:: int uv_pipe_pending_count(uv_pipe_t* handle)
+.. c:function:: uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle)
+
+    Used to receive handles over IPC pipes.
+
+    First - call :c:func:`uv_pipe_pending_count`, if it's > 0 then initialize
+    a handle of the given `type`, returned by :c:func:`uv_pipe_pending_type`
+    and call ``uv_accept(pipe, handle)``.
+
+.. seealso:: The :c:type:`uv_stream_t` API functions also apply.
+
+.. c:function:: int uv_pipe_chmod(uv_pipe_t* handle, int flags)
+
+    Alters pipe permissions, allowing it to be accessed from processes run by
+    different users. Makes the pipe writable or readable by all users. Mode can
+    be ``UV_WRITABLE``, ``UV_READABLE`` or ``UV_WRITABLE | UV_READABLE``. This
+    function is blocking.
+
+    .. versionadded:: 1.16.0
+
+.. c:function:: int uv_pipe(uv_file fds[2], int read_flags, int write_flags)
+
+    Create a pair of connected pipe handles.
+    Data may be written to `fds[1]` and read from `fds[0]`.
+    The resulting handles can be passed to `uv_pipe_open`, used with `uv_spawn`,
+    or for any other purpose.
+
+    Valid values for `flags` are:
+
+      - UV_NONBLOCK_PIPE: Opens the specified socket handle for `OVERLAPPED`
+        or `FIONBIO`/`O_NONBLOCK` I/O usage.
+        This is recommended for handles that will be used by libuv,
+        and not usually recommended otherwise.
+
+    Equivalent to :man:`pipe(2)` with the `O_CLOEXEC` flag set.
+
+    .. versionadded:: 1.41.0

deps/uv/docs/src/poll.rst

@@ -0,0 +1,150 @@
+
+.. _poll:
+
+:c:type:`uv_poll_t` --- Poll handle
+===================================
+
+Poll handles are used to watch file descriptors for readability,
+writability and disconnection similar to the purpose of :man:`poll(2)`.
+
+The purpose of poll handles is to enable integrating external libraries that
+rely on the event loop to signal it about the socket status changes, like
+c-ares or libssh2. Using uv_poll_t for any other purpose is not recommended;
+:c:type:`uv_tcp_t`, :c:type:`uv_udp_t`, etc. provide an implementation that is faster and
+more scalable than what can be achieved with :c:type:`uv_poll_t`, especially on
+Windows.
+
+It is possible that poll handles occasionally signal that a file descriptor is
+readable or writable even when it isn't. The user should therefore always
+be prepared to handle EAGAIN or equivalent when it attempts to read from or
+write to the fd.
+
+It is not okay to have multiple active poll handles for the same socket, this
+can cause libuv to busyloop or otherwise malfunction.
+
+The user should not close a file descriptor while it is being polled by an
+active poll handle. This can cause the handle to report an error,
+but it might also start polling another socket. However the fd can be safely
+closed immediately after a call to :c:func:`uv_poll_stop` or :c:func:`uv_close`.
+
+.. note::
+    On windows only sockets can be polled with poll handles. On Unix any file
+    descriptor that would be accepted by :man:`poll(2)` can be used.
+
+.. note::
+    On AIX, watching for disconnection is not supported.
+
+Data types
+----------
+
+.. c:type:: uv_poll_t
+
+    Poll handle type.
+
+.. c:type:: void (*uv_poll_cb)(uv_poll_t* handle, int status, int events)
+
+    Type definition for callback passed to :c:func:`uv_poll_start`.
+
+.. c:enum:: uv_poll_event
+
+    Poll event types
+
+    ::
+
+        enum uv_poll_event {
+            UV_READABLE = 1,
+            UV_WRITABLE = 2,
+            UV_DISCONNECT = 4,
+            UV_PRIORITIZED = 8
+        };
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd)
+
+    Initialize the handle using a file descriptor.
+
+    .. versionchanged:: 1.2.2 the file descriptor is set to non-blocking mode.
+
+.. c:function:: int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle, uv_os_sock_t socket)
+
+    Initialize the handle using a socket descriptor. On Unix this is identical
+    to :c:func:`uv_poll_init`. On windows it takes a SOCKET handle.
+
+    .. versionchanged:: 1.2.2 the socket is set to non-blocking mode.
+
+.. c:function:: int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb)
+
+    Starts polling the file descriptor. `events` is a bitmask made up of
+    `UV_READABLE`, `UV_WRITABLE`, `UV_PRIORITIZED` and `UV_DISCONNECT`. As soon
+    as an event is detected the callback will be called with `status` set to 0,
+    and the detected events set on the `events` field.
+
+    The `UV_PRIORITIZED` event is used to watch for sysfs interrupts or TCP
+    out-of-band messages.
+
+    The `UV_DISCONNECT` event is optional in the sense that it may not be
+    reported and the user is free to ignore it, but it can help optimize the
+    shutdown path because an extra read or write call might be avoided.
+
+    If an error happens while polling, `status` will be < 0 and corresponds
+    with one of the `UV_E*` error codes (see :ref:`errors`). The user should
+    not close the socket while the handle is active. If the user does that
+    anyway, the callback *may* be called reporting an error status, but this is
+    **not** guaranteed. If `status == UV_EBADF` polling is discontinued for the
+    file handle and no further events will be reported. The user should
+    then call :c:func:`uv_close` on the handle.
+
+    .. note::
+        Calling :c:func:`uv_poll_start` on a handle that is already active is
+        fine. Doing so will update the events mask that is being watched for.
+
+    .. note::
+        Though `UV_DISCONNECT` can be set, it is unsupported on AIX and as such
+        will not be set on the `events` field in the callback.
+
+    .. note::
+        If one of the events `UV_READABLE` or `UV_WRITABLE` are set, the
+        callback will be called again, as long as the given fd/socket remains
+        readable or writable accordingly. Particularly in each of the following
+        scenarios:
+
+        * The callback has been called because the socket became
+          readable/writable and the callback did not conduct a read/write on
+          this socket at all.
+        * The callback committed a read on the socket, and has not read all the
+          available data (when `UV_READABLE` is set).
+        * The callback committed a write on the socket, but it remained
+          writable afterwards (when `UV_WRITABLE` is set).
+        * The socket has already became readable/writable before calling
+          :c:func:`uv_poll_start` on a poll handle associated with this socket,
+          and since then the state of the socket did not changed.
+
+        In all of the above listed scenarios, the socket remains readable or
+        writable and hence the callback will be called again (depending on the
+        events set in the bitmask). This behaviour is known as level
+        triggering.
+
+    .. versionchanged:: 1.9.0 Added the `UV_DISCONNECT` event.
+    .. versionchanged:: 1.14.0 Added the `UV_PRIORITIZED` event.
+
+.. c:function:: int uv_poll_stop(uv_poll_t* poll)
+
+    Stop polling the file descriptor, the callback will no longer be called.
+
+    .. note::
+        Calling :c:func:`uv_poll_stop` is effective immediately: any pending
+        callback is also canceled, even if the socket state change notification
+        was already pending.
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/prepare.rst

@@ -0,0 +1,54 @@
+
+.. _prepare:
+
+:c:type:`uv_prepare_t` --- Prepare handle
+=========================================
+
+Prepare handles will run the given callback once per loop iteration, right
+before polling for i/o.
+
+
+Data types
+----------
+
+.. c:type:: uv_prepare_t
+
+    Prepare handle type.
+
+.. c:type:: void (*uv_prepare_cb)(uv_prepare_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_prepare_start`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_prepare_init(uv_loop_t* loop, uv_prepare_t* prepare)
+
+    Initialize the handle. This function always succeeds.
+
+    :returns: 0
+
+.. c:function:: int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb)
+
+    Start the handle with the given callback. This function always succeeds,
+    except when `cb` is `NULL`.
+
+    :returns: 0 on success, or `UV_EINVAL` when `cb == NULL`.
+
+.. c:function:: int uv_prepare_stop(uv_prepare_t* prepare)
+
+    Stop the handle, the callback will no longer be called.
+    This function always succeeds.
+
+    :returns: 0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/process.rst

@@ -0,0 +1,291 @@
+
+.. _process:
+
+:c:type:`uv_process_t` --- Process handle
+=========================================
+
+Process handles will spawn a new process and allow the user to control it and
+establish communication channels with it using streams.
+
+
+Data types
+----------
+
+.. c:type:: uv_process_t
+
+    Process handle type.
+
+.. c:type:: uv_process_options_t
+
+    Options for spawning the process (passed to :c:func:`uv_spawn`.
+
+    ::
+
+        typedef struct uv_process_options_s {
+            uv_exit_cb exit_cb;
+            const char* file;
+            char** args;
+            char** env;
+            const char* cwd;
+            unsigned int flags;
+            int stdio_count;
+            uv_stdio_container_t* stdio;
+            uv_uid_t uid;
+            uv_gid_t gid;
+        } uv_process_options_t;
+
+.. c:type:: void (*uv_exit_cb)(uv_process_t*, int64_t exit_status, int term_signal)
+
+    Type definition for callback passed in :c:type:`uv_process_options_t` which
+    will indicate the exit status and the signal that caused the process to
+    terminate, if any.
+
+.. c:enum:: uv_process_flags
+
+    Flags to be set on the flags field of :c:type:`uv_process_options_t`.
+
+    ::
+
+        enum uv_process_flags {
+            /*
+            * Set the child process' user id.
+            */
+            UV_PROCESS_SETUID = (1 << 0),
+            /*
+            * Set the child process' group id.
+            */
+            UV_PROCESS_SETGID = (1 << 1),
+            /*
+            * Do not wrap any arguments in quotes, or perform any other escaping, when
+            * converting the argument list into a command line string. This option is
+            * only meaningful on Windows systems. On Unix it is silently ignored.
+            */
+            UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2),
+            /*
+            * Spawn the child process in a detached state - this will make it a process
+            * group leader, and will effectively enable the child to keep running after
+            * the parent exits. Note that the child process will still keep the
+            * parent's event loop alive unless the parent process calls uv_unref() on
+            * the child's process handle.
+            */
+            UV_PROCESS_DETACHED = (1 << 3),
+            /*
+            * Hide the subprocess window that would normally be created. This option is
+            * only meaningful on Windows systems. On Unix it is silently ignored.
+            */
+            UV_PROCESS_WINDOWS_HIDE = (1 << 4),
+            /*
+            * Hide the subprocess console window that would normally be created. This 
+            * option is only meaningful on Windows systems. On Unix it is silently
+            * ignored.
+            */
+            UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5),
+            /*
+            * Hide the subprocess GUI window that would normally be created. This 
+            * option is only meaningful on Windows systems. On Unix it is silently
+            * ignored.
+            */
+            UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6),
+            /*
+             * On Windows, if the path to the program to execute, specified in
+             * uv_process_options_t's file field, has a directory component,
+             * search for the exact file name before trying variants with
+             * extensions like '.exe' or '.cmd'.
+             */
+            UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7)
+        };
+
+.. c:type:: uv_stdio_container_t
+
+    Container for each stdio handle or fd passed to a child process.
+
+    ::
+
+        typedef struct uv_stdio_container_s {
+            uv_stdio_flags flags;
+            union {
+                uv_stream_t* stream;
+                int fd;
+            } data;
+        } uv_stdio_container_t;
+
+.. c:enum:: uv_stdio_flags
+
+    Flags specifying how a stdio should be transmitted to the child process.
+
+    ::
+
+        typedef enum {
+            /*
+            * The following four options are mutually-exclusive, and define
+            * the operation to perform for the corresponding file descriptor
+            * in the child process:
+            */
+
+            /*
+            * No file descriptor will be provided (or redirected to
+            * `/dev/null` if it is fd 0, 1 or 2).
+            */
+            UV_IGNORE = 0x00,
+
+            /*
+            * Open a new pipe into `data.stream`, per the flags below. The
+            * `data.stream` field must point to a uv_pipe_t object that has
+            * been initialized with `uv_pipe_init(loop, data.stream, ipc);`,
+            * but not yet opened or connected.
+            /*
+            UV_CREATE_PIPE = 0x01,
+
+            /*
+            * The child process will be given a duplicate of the parent's
+            * file descriptor given by `data.fd`.
+            */
+            UV_INHERIT_FD = 0x02,
+
+            /*
+            * The child process will be given a duplicate of the parent's
+            * file descriptor being used by the stream handle given by
+            * `data.stream`.
+            */
+            UV_INHERIT_STREAM = 0x04,
+
+            /*
+            * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE
+            * determine the direction of flow, from the child process' perspective. Both
+            * flags may be specified to create a duplex data stream.
+            */
+            UV_READABLE_PIPE = 0x10,
+            UV_WRITABLE_PIPE = 0x20,
+
+            /*
+            * When UV_CREATE_PIPE is specified, specifying UV_NONBLOCK_PIPE opens the
+            * handle in non-blocking mode in the child. This may cause loss of data,
+            * if the child is not designed to handle to encounter this mode,
+            * but can also be significantly more efficient.
+            */
+            UV_NONBLOCK_PIPE = 0x40
+        } uv_stdio_flags;
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: int uv_process_t.pid
+
+    The PID of the spawned process. It's set after calling :c:func:`uv_spawn`.
+
+.. note::
+    The :c:type:`uv_handle_t` members also apply.
+
+.. c:member:: uv_exit_cb uv_process_options_t.exit_cb
+
+    Callback called after the process exits.
+
+.. c:member:: const char* uv_process_options_t.file
+
+    Path pointing to the program to be executed.
+
+.. c:member:: char** uv_process_options_t.args
+
+    Command line arguments. args[0] should be the path to the program. On
+    Windows this uses `CreateProcess` which concatenates the arguments into a
+    string this can cause some strange errors. See the
+    ``UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS`` flag on :c:enum:`uv_process_flags`.
+
+.. c:member:: char** uv_process_options_t.env
+
+    Environment for the new process. If NULL the parents environment is used.
+
+.. c:member:: const char* uv_process_options_t.cwd
+
+    Current working directory for the subprocess.
+
+.. c:member:: unsigned int uv_process_options_t.flags
+
+    Various flags that control how :c:func:`uv_spawn` behaves. See
+    :c:enum:`uv_process_flags`.
+
+.. c:member:: int uv_process_options_t.stdio_count
+.. c:member:: uv_stdio_container_t* uv_process_options_t.stdio
+
+    The `stdio` field points to an array of :c:type:`uv_stdio_container_t`
+    structs that describe the file descriptors that will be made available to
+    the child process. The convention is that stdio[0] points to stdin,
+    fd 1 is used for stdout, and fd 2 is stderr.
+
+    .. note::
+        On Windows file descriptors greater than 2 are available to the child process only if
+        the child processes uses the MSVCRT runtime.
+
+.. c:member:: uv_uid_t uv_process_options_t.uid
+.. c:member:: uv_gid_t uv_process_options_t.gid
+
+    Libuv can change the child process' user/group id. This happens only when
+    the appropriate bits are set in the flags fields.
+
+    .. note::
+        This is not supported on Windows, :c:func:`uv_spawn` will fail and set the error
+        to ``UV_ENOTSUP``.
+
+.. c:member:: uv_stdio_flags uv_stdio_container_t.flags
+
+    Flags specifying how the stdio container should be passed to the child.
+
+.. c:member:: union @0 uv_stdio_container_t.data
+
+    Union containing either the `stream` or `fd` to be passed on to the child
+    process.
+
+
+API
+---
+
+.. c:function:: void uv_disable_stdio_inheritance(void)
+
+    Disables inheritance for file descriptors / handles that this process
+    inherited from its parent. The effect is that child processes spawned by
+    this process don't accidentally inherit these handles.
+
+    It is recommended to call this function as early in your program as possible,
+    before the inherited file descriptors can be closed or duplicated.
+
+    .. note::
+        This function works on a best-effort basis: there is no guarantee that libuv can discover
+        all file descriptors that were inherited. In general it does a better job on Windows than
+        it does on Unix.
+
+.. c:function:: int uv_spawn(uv_loop_t* loop, uv_process_t* handle, const uv_process_options_t* options)
+
+    Initializes the process handle and starts the process. If the process is
+    successfully spawned, this function will return 0. Otherwise, the
+    negative error code corresponding to the reason it couldn't spawn is
+    returned.
+
+    Possible reasons for failing to spawn would include (but not be limited to)
+    the file to execute not existing, not having permissions to use the setuid or
+    setgid specified, or not having enough memory to allocate for the new
+    process.
+
+    .. versionchanged:: 1.24.0 Added `UV_PROCESS_WINDOWS_HIDE_CONSOLE` and
+                        `UV_PROCESS_WINDOWS_HIDE_GUI` flags.
+
+    .. versionchanged:: 1.48.0 Added the
+                        `UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME` flag.
+
+.. c:function:: int uv_process_kill(uv_process_t* handle, int signum)
+
+    Sends the specified signal to the given process handle. Check the documentation
+    on :c:ref:`signal` for signal support, specially on Windows.
+
+.. c:function:: int uv_kill(int pid, int signum)
+
+    Sends the specified signal to the given PID. Check the documentation
+    on :c:ref:`signal` for signal support, specially on Windows.
+
+.. c:function:: uv_pid_t uv_process_get_pid(const uv_process_t* handle)
+
+    Returns `handle->pid`.
+
+    .. versionadded:: 1.19.0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/request.rst

@@ -0,0 +1,121 @@
+
+.. _request:
+
+:c:type:`uv_req_t` --- Base request
+===================================
+
+`uv_req_t` is the base type for all libuv request types.
+
+Structures are aligned so that any libuv request can be cast to `uv_req_t`.
+All API functions defined here work with any request type.
+
+
+Data types
+----------
+
+.. c:type:: uv_req_t
+
+    The base libuv request structure.
+
+.. c:type:: uv_any_req
+
+    Union of all request types.
+
+.. c:enum:: uv_req_type
+
+    The kind of the libuv request.
+
+    ::
+
+        typedef enum {
+            UV_UNKNOWN_REQ = 0,
+            UV_REQ,
+            UV_CONNECT,
+            UV_WRITE,
+            UV_SHUTDOWN,
+            UV_UDP_SEND,
+            UV_FS,
+            UV_WORK,
+            UV_GETADDRINFO,
+            UV_GETNAMEINFO,
+            UV_REQ_TYPE_MAX,
+        } uv_req_type;
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: void* uv_req_t.data
+
+    Space for user-defined arbitrary data. libuv does not use this field.
+
+.. c:member:: uv_req_type uv_req_t.type
+
+    The :c:enum:`uv_req_type`, indicating the type of the request. Readonly.
+
+
+API
+---
+
+.. c:macro:: UV_REQ_TYPE_MAP(iter_macro)
+
+    Macro that expands to a series of invocations of `iter_macro` for
+    each of the request types. `iter_macro` is invoked with two
+    arguments: the name of the `uv_req_type` element without the `UV_`
+    prefix, and the name of the corresponding structure type without the
+    `uv_` prefix and `_t` suffix.
+
+.. c:function:: int uv_cancel(uv_req_t* req)
+
+    Cancel a pending request. Fails if the request is executing or has finished
+    executing.
+
+    Returns 0 on success, or an error code < 0 on failure.
+
+    Only cancellation of :c:type:`uv_fs_t`, :c:type:`uv_getaddrinfo_t`,
+    :c:type:`uv_getnameinfo_t`, :c:type:`uv_random_t` and :c:type:`uv_work_t`
+    requests is currently supported.
+
+    Cancelled requests have their callbacks invoked some time in the future.
+    It's **not** safe to free the memory associated with the request until the
+    callback is called.
+
+    Here is how cancellation is reported to the callback:
+
+    * A :c:type:`uv_fs_t` request has its req->result field set to `UV_ECANCELED`.
+
+    * A :c:type:`uv_work_t`, :c:type:`uv_getaddrinfo_t`,
+      :c:type:`uv_getnameinfo_t` or :c:type:`uv_random_t` request has its
+      callback invoked with status == `UV_ECANCELED`.
+
+.. c:function:: size_t uv_req_size(uv_req_type type)
+
+    Returns the size of the given request type. Useful for FFI binding writers
+    who don't want to know the structure layout.
+
+.. c:function:: void* uv_req_get_data(const uv_req_t* req)
+
+    Returns `req->data`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: void uv_req_set_data(uv_req_t* req, void* data)
+
+    Sets `req->data` to `data`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: uv_req_type uv_req_get_type(const uv_req_t* req)
+
+    Returns `req->type`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: const char* uv_req_type_name(uv_req_type type)
+
+    Returns the name for the equivalent struct for a given request type,
+    e.g. `"connect"` (as in :c:type:`uv_connect_t`) for `UV_CONNECT`.
+
+    If no such request type exists, this returns `NULL`.
+
+    .. versionadded:: 1.19.0

deps/uv/docs/src/signal.rst

@@ -0,0 +1,101 @@
+
+.. _signal:
+
+:c:type:`uv_signal_t` --- Signal handle
+=======================================
+
+Signal handles implement Unix style signal handling on a per-event loop bases.
+
+Windows notes
+-------------
+
+Reception of some signals is emulated:
+
+* SIGINT is normally delivered when the user presses CTRL+C. However, like
+  on Unix, it is not generated when terminal raw mode is enabled.
+
+* SIGBREAK is delivered when the user pressed CTRL + BREAK.
+
+* SIGHUP is generated when the user closes the console window. On SIGHUP the
+  program is given approximately 10 seconds to perform cleanup. After that
+  Windows will unconditionally terminate it.
+
+* SIGWINCH is raised whenever libuv detects that the console has been
+  resized. When a libuv app is running under a console emulator, or when a
+  32-bit libuv app is running on 64-bit system, SIGWINCH will be emulated. In
+  such cases SIGWINCH signals may not always be delivered in a timely manner.
+  For a writable :c:type:`uv_tty_t` handle libuv will only detect size changes
+  when the cursor is moved. When a readable :c:type:`uv_tty_t` handle is used,
+  resizing of the console buffer will be detected only if the handle is in raw
+  mode and is being read.
+
+* Watchers for other signals can be successfully created, but these signals
+  are never received. These signals are: `SIGILL`, `SIGABRT`, `SIGFPE`, `SIGSEGV`,
+  `SIGTERM` and `SIGKILL.`
+
+* Calls to raise() or abort() to programmatically raise a signal are
+  not detected by libuv; these will not trigger a signal watcher.
+
+.. versionchanged:: 1.15.0 SIGWINCH support on Windows was improved.
+.. versionchanged:: 1.31.0 32-bit libuv SIGWINCH support on 64-bit Windows was
+                           rolled back to old implementation.
+
+Unix notes
+----------
+
+* SIGKILL and SIGSTOP are impossible to catch.
+
+* Handling SIGBUS, SIGFPE, SIGILL or SIGSEGV via libuv results into undefined behavior.
+
+* SIGABRT will not be caught by libuv if generated by `abort()`, e.g. through `assert()`.
+
+* On Linux SIGRT0 and SIGRT1 (signals 32 and 33) are used by the NPTL pthreads library to
+  manage threads. Installing watchers for those signals will lead to unpredictable behavior
+  and is strongly discouraged. Future versions of libuv may simply reject them.
+
+
+Data types
+----------
+
+.. c:type:: uv_signal_t
+
+    Signal handle type.
+
+.. c:type:: void (*uv_signal_cb)(uv_signal_t* handle, int signum)
+
+    Type definition for callback passed to :c:func:`uv_signal_start`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: int uv_signal_t.signum
+
+    Signal being monitored by this handle. Readonly.
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_signal_init(uv_loop_t* loop, uv_signal_t* signal)
+
+    Initialize the handle.
+
+.. c:function:: int uv_signal_start(uv_signal_t* signal, uv_signal_cb cb, int signum)
+
+    Start the handle with the given callback, watching for the given signal.
+
+.. c:function:: int uv_signal_start_oneshot(uv_signal_t* signal, uv_signal_cb cb, int signum)
+
+    .. versionadded:: 1.12.0
+
+    Same functionality as :c:func:`uv_signal_start` but the signal handler is reset the moment
+    the signal is received.
+
+.. c:function:: int uv_signal_stop(uv_signal_t* signal)
+
+    Stop the handle, the callback will no longer be called.
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/sphinx-plugins/manpage.py

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+#
+# Copyright (c) 2013 Dariusz Dwornikowski.  All rights reserved.
+#
+# Adapted from https://github.com/tdi/sphinxcontrib-manpage
+# License: Apache 2
+#
+
+
+import re
+
+from docutils import nodes, utils
+from docutils.parsers.rst.roles import set_classes
+from string import Template
+
+
+def make_link_node(rawtext, app, name, manpage_num, options):
+    ref = app.config.man_url_regex
+    if not ref:
+        ref = "https://man7.org/linux/man-pages/man%s/%s.%s.html" %(manpage_num, name, manpage_num)
+    else:
+        s = Template(ref)
+        ref = s.substitute(num=manpage_num, topic=name)
+    set_classes(options)
+    node = nodes.reference(rawtext, "%s(%s)" % (name, manpage_num), refuri=ref, **options)
+    return node
+
+
+def man_role(name, rawtext, text, lineno, inliner, options={}, content=[]):
+    app = inliner.document.settings.env.app
+    p = re.compile("([a-zA-Z0-9_\.-_]+)\((\d)\)")
+    m = p.match(text)
+
+    manpage_num = m.group(2)
+    name = m.group(1)
+    node = make_link_node(rawtext, app, name, manpage_num, options)
+    return [node], []
+
+
+def setup(app):
+    app.add_role('man', man_role)
+    app.add_config_value('man_url_regex', None, 'env')
+    return
+

deps/uv/docs/src/static/diagrams.key/Metadata/BuildVersionHistory.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<array>
+	<string>Template: White (2014-02-28 09:41)</string>
+	<string>M6.2.2-1878-1</string>
+</array>
+</plist>

deps/uv/docs/src/static/diagrams.key/Metadata/DocumentIdentifier

@@ -0,0 +1 @@
+F69E9CD9-EEF1-4223-9DA4-A1EA7FE112BA

deps/uv/docs/src/stream.rst

@@ -0,0 +1,258 @@
+
+.. _stream:
+
+:c:type:`uv_stream_t` --- Stream handle
+=======================================
+
+Stream handles provide an abstraction of a duplex communication channel.
+:c:type:`uv_stream_t` is an abstract type, libuv provides 3 stream implementations
+in the form of :c:type:`uv_tcp_t`, :c:type:`uv_pipe_t` and :c:type:`uv_tty_t`.
+
+
+Data types
+----------
+
+.. c:type:: uv_stream_t
+
+    Stream handle type.
+
+.. c:type:: uv_connect_t
+
+    Connect request type.
+
+.. c:type:: uv_shutdown_t
+
+    Shutdown request type.
+
+.. c:type:: uv_write_t
+
+    Write request type. Careful attention must be paid when reusing objects of
+    this type. When a stream is in non-blocking mode, write requests sent
+    with ``uv_write`` will be queued. Reusing objects at this point is undefined
+    behaviour. It is safe to reuse the ``uv_write_t`` object only after the
+    callback passed to ``uv_write`` is fired.
+
+.. c:type:: void (*uv_read_cb)(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf)
+
+    Callback called when data was read on a stream.
+
+    `nread` is > 0 if there is data available or < 0 on error. When we've
+    reached EOF, `nread` will be set to ``UV_EOF``. When `nread` < 0,
+    the `buf` parameter might not point to a valid buffer; in that case
+    `buf.len` and `buf.base` are both set to 0.
+
+    .. note::
+        `nread` might be 0, which does *not* indicate an error or EOF. This
+        is equivalent to ``EAGAIN`` or ``EWOULDBLOCK`` under ``read(2)``.
+
+    The callee is responsible for stopping/closing the stream when an error happens
+    by calling :c:func:`uv_read_stop` or :c:func:`uv_close`. Trying to read
+    from the stream again is undefined.
+
+    The callee is responsible for freeing the buffer, libuv does not reuse it.
+    The buffer may be a null buffer (where `buf->base` == NULL and `buf->len` == 0)
+    on error.
+
+.. c:type:: void (*uv_write_cb)(uv_write_t* req, int status)
+
+    Callback called after data was written on a stream. `status` will be 0 in
+    case of success, < 0 otherwise.
+
+.. c:type:: void (*uv_connect_cb)(uv_connect_t* req, int status)
+
+    Callback called after a connection started by :c:func:`uv_connect` is done.
+    `status` will be 0 in case of success, < 0 otherwise.
+
+.. c:type:: void (*uv_shutdown_cb)(uv_shutdown_t* req, int status)
+
+    Callback called after a shutdown request has been completed. `status` will
+    be 0 in case of success, < 0 otherwise.
+
+.. c:type:: void (*uv_connection_cb)(uv_stream_t* server, int status)
+
+    Callback called when a stream server has received an incoming connection.
+    The user can accept the connection by calling :c:func:`uv_accept`.
+    `status` will be 0 in case of success, < 0 otherwise.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: size_t uv_stream_t.write_queue_size
+
+    Contains the amount of queued bytes waiting to be sent. Readonly.
+
+.. c:member:: uv_stream_t* uv_connect_t.handle
+
+    Pointer to the stream where this connection request is running.
+
+.. c:member:: uv_stream_t* uv_shutdown_t.handle
+
+    Pointer to the stream where this shutdown request is running.
+
+.. c:member:: uv_stream_t* uv_write_t.handle
+
+    Pointer to the stream where this write request is running.
+
+.. c:member:: uv_stream_t* uv_write_t.send_handle
+
+    Pointer to the stream being sent using this write request.
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb)
+
+    Shutdown the outgoing (write) side of a duplex stream. It waits for pending
+    write requests to complete. The `handle` should refer to a initialized stream.
+    `req` should be an uninitialized shutdown request struct. The `cb` is called
+    after shutdown is complete.
+
+.. c:function:: int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb)
+
+    Start listening for incoming connections. `backlog` indicates the number of
+    connections the kernel might queue, same as :man:`listen(2)`. When a new
+    incoming connection is received the :c:type:`uv_connection_cb` callback is
+    called.
+
+.. c:function:: int uv_accept(uv_stream_t* server, uv_stream_t* client)
+
+    This call is used in conjunction with :c:func:`uv_listen` to accept incoming
+    connections. Call this function after receiving a :c:type:`uv_connection_cb`
+    to accept the connection. Before calling this function the client handle must
+    be initialized. < 0 return value indicates an error.
+
+    When the :c:type:`uv_connection_cb` callback is called it is guaranteed that
+    this function will complete successfully the first time. If you attempt to use
+    it more than once, it may fail. It is suggested to only call this function once
+    per :c:type:`uv_connection_cb` call.
+
+    .. note::
+        `server` and `client` must be handles running on the same loop.
+
+.. c:function:: int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
+
+    Read data from an incoming stream. The :c:type:`uv_read_cb` callback will
+    be made several times until there is no more data to read or
+    :c:func:`uv_read_stop` is called.
+
+    .. versionchanged:: 1.38.0 :c:func:`uv_read_start()` now consistently
+      returns `UV_EALREADY` when called twice, and `UV_EINVAL` when the
+      stream is closing. With older libuv versions, it returns `UV_EALREADY`
+      on Windows but not UNIX, and `UV_EINVAL` on UNIX but not Windows.
+
+.. c:function:: int uv_read_stop(uv_stream_t*)
+
+    Stop reading data from the stream. The :c:type:`uv_read_cb` callback will
+    no longer be called.
+
+    This function is idempotent and may be safely called on a stopped stream.
+
+    This function will always succeed; hence, checking its return value is
+    unnecessary. A non-zero return indicates that finishing releasing resources
+    may be pending on the next input event on that TTY on Windows, and does not
+    indicate failure.
+
+.. c:function:: int uv_write(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
+
+    Write data to stream. Buffers are written in order. Example:
+
+    ::
+
+        void cb(uv_write_t* req, int status) {
+            /* Logic which handles the write result */
+        }
+
+        uv_buf_t a[] = {
+            { .base = "1", .len = 1 },
+            { .base = "2", .len = 1 }
+        };
+
+        uv_buf_t b[] = {
+            { .base = "3", .len = 1 },
+            { .base = "4", .len = 1 }
+        };
+
+        uv_write_t req1;
+        uv_write_t req2;
+
+        /* writes "1234" */
+        uv_write(&req1, stream, a, 2, cb);
+        uv_write(&req2, stream, b, 2, cb);
+
+    .. note::
+        The memory pointed to by the buffers must remain valid until the callback gets called.
+        This also holds for :c:func:`uv_write2`.
+
+.. c:function:: int uv_write2(uv_write_t* req, uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle, uv_write_cb cb)
+
+    Extended write function for sending handles over a pipe. The pipe must be
+    initialized with `ipc` == 1.
+
+    .. note::
+        `send_handle` must be a TCP, pipe and UDP handle on Unix, or a TCP
+        handle on Windows, which is a server or a connection (listening or
+        connected state). Bound sockets or pipes will be assumed to be servers.
+
+.. c:function:: int uv_try_write(uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs)
+
+    Same as :c:func:`uv_write`, but won't queue a write request if it can't be
+    completed immediately.
+
+    Will return either:
+
+    * > 0: number of bytes written (can be less than the supplied buffer size).
+    * < 0: negative error code (``UV_EAGAIN`` is returned if no data can be sent
+      immediately).
+
+.. c:function:: int uv_try_write2(uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle)
+
+    Same as :c:func:`uv_try_write` and extended write function for sending
+    handles over a pipe like c:func:`uv_write2`.
+
+    Try to send a handle is not supported on Windows,
+    where it returns ``UV_EAGAIN``.
+
+    .. versionadded:: 1.42.0
+    
+.. c:function:: int uv_is_readable(const uv_stream_t* handle)
+
+    Returns 1 if the stream is readable, 0 otherwise.
+
+.. c:function:: int uv_is_writable(const uv_stream_t* handle)
+
+    Returns 1 if the stream is writable, 0 otherwise.
+
+.. c:function:: int uv_stream_set_blocking(uv_stream_t* handle, int blocking)
+
+    Enable or disable blocking mode for a stream.
+
+    When blocking mode is enabled all writes complete synchronously. The
+    interface remains unchanged otherwise, e.g. completion or failure of the
+    operation will still be reported through a callback which is made
+    asynchronously.
+
+    .. warning::
+        Relying too much on this API is not recommended. It is likely to change
+        significantly in the future.
+
+        Currently only works on Windows for :c:type:`uv_pipe_t` handles.
+        On UNIX platforms, all :c:type:`uv_stream_t` handles are supported.
+
+        Also libuv currently makes no ordering guarantee when the blocking mode
+        is changed after write requests have already been submitted. Therefore it is
+        recommended to set the blocking mode immediately after opening or creating
+        the stream.
+
+    .. versionchanged:: 1.4.0 UNIX implementation added.
+
+.. c:function:: size_t uv_stream_get_write_queue_size(const uv_stream_t* stream)
+
+    Returns `stream->write_queue_size`.
+
+    .. versionadded:: 1.19.0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/tcp.rst

@@ -0,0 +1,190 @@
+
+.. _tcp:
+
+:c:type:`uv_tcp_t` --- TCP handle
+=================================
+
+TCP handles are used to represent both TCP streams and servers.
+
+:c:type:`uv_tcp_t` is a 'subclass' of :c:type:`uv_stream_t`.
+
+
+Data types
+----------
+
+.. c:type:: uv_tcp_t
+
+    TCP handle type.
+
+.. c:enum:: uv_tcp_flags
+
+    Flags used in :c:func:`uv_tcp_bind`.
+
+    ::
+
+        enum uv_tcp_flags {
+            /* Used with uv_tcp_bind, when an IPv6 address is used. */
+            UV_TCP_IPV6ONLY = 1,
+
+            /* Enable SO_REUSEPORT socket option when binding the handle.
+             * This allows completely duplicate bindings by multiple processes
+             * or threads if they all set SO_REUSEPORT before binding the port.
+             * Incoming connections are distributed across the participating
+             * listener sockets.
+             *
+             * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,
+             * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now.
+             */
+            UV_TCP_REUSEPORT = 2,
+        };
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_stream_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* handle)
+
+    Initialize the handle. No socket is created as of yet.
+
+.. c:function:: int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* handle, unsigned int flags)
+
+    Initialize the handle with the specified flags. At the moment only the lower 8 bits
+    of the `flags` parameter are used as the socket domain. A socket will be created
+    for the given domain. If the specified domain is ``AF_UNSPEC`` no socket is created,
+    just like :c:func:`uv_tcp_init`.
+
+    .. versionadded:: 1.7.0
+
+.. c:function:: int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock)
+
+    Open an existing file descriptor or SOCKET as a TCP handle.
+
+    .. versionchanged:: 1.2.1 the file descriptor is set to non-blocking mode.
+
+    .. note::
+        The passed file descriptor or SOCKET is not checked for its type, but
+        it's required that it represents a valid stream socket.
+
+.. c:function:: int uv_tcp_nodelay(uv_tcp_t* handle, int enable)
+
+    Enable `TCP_NODELAY`, which disables Nagle's algorithm.
+
+.. c:function:: int uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay)
+
+    Enable / disable TCP keep-alive. `delay` is the initial delay in seconds,
+    ignored when `enable` is zero.
+
+    After `delay` has been reached, 10 successive probes, each spaced 1 second
+    from the previous one, will still happen. If the connection is still lost
+    at the end of this procedure, then the handle is destroyed with a
+    ``UV_ETIMEDOUT`` error passed to the corresponding callback.
+
+    If `delay` is less than 1 then ``UV_EINVAL`` is returned.
+
+    .. versionchanged:: 1.49.0 If `delay` is less than 1 then ``UV_EINVAL``` is returned.
+
+.. c:function:: int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable)
+
+    Enable / disable simultaneous asynchronous accept requests that are
+    queued by the operating system when listening for new TCP connections.
+
+    This setting is used to tune a TCP server for the desired performance.
+    Having simultaneous accepts can significantly improve the rate of accepting
+    connections (which is why it is enabled by default) but may lead to uneven
+    load distribution in multi-process setups.
+
+.. c:function:: int uv_tcp_bind(uv_tcp_t* handle, const struct sockaddr* addr, unsigned int flags)
+
+    Bind the handle to an address and port.
+
+    When the port is already taken, you can expect to see an ``UV_EADDRINUSE``
+    error from :c:func:`uv_listen` or :c:func:`uv_tcp_connect` unless you specify
+    ``UV_TCP_REUSEPORT`` in `flags` for all the binding sockets. That is, a successful
+    call to this function does not guarantee that the call to :c:func:`uv_listen` or
+    :c:func:`uv_tcp_connect` will succeed as well.
+
+    :param handle: TCP handle. It should have been initialized with :c:func:`uv_tcp_init`.
+
+    :param addr: Address to bind to. It should point to an initialized ``struct sockaddr_in``
+        or ``struct sockaddr_in6``.
+
+    :param flags: Flags that control the behavior of binding the socket.
+        ``UV_TCP_IPV6ONLY`` can be contained in `flags` to disable dual-stack
+        support and only use IPv6. 
+        ``UV_TCP_REUSEPORT`` can be contained in `flags` to enable the socket option
+        `SO_REUSEPORT` with the capability of load balancing that distribute incoming
+        connections across all listening sockets in multiple processes or threads. 
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. versionchanged:: 1.49.0 added the ``UV_TCP_REUSEPORT`` flag.
+
+    .. note::
+        ``UV_TCP_REUSEPORT`` flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,
+        FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ at the moment. On other platforms
+        this function will return an UV_ENOTSUP error.
+
+.. c:function:: int uv_tcp_getsockname(const uv_tcp_t* handle, struct sockaddr* name, int* namelen)
+
+    Get the current address to which the handle is bound. `name` must point to
+    a valid and big enough chunk of memory, ``struct sockaddr_storage`` is
+    recommended for IPv4 and IPv6 support.
+
+.. c:function:: int uv_tcp_getpeername(const uv_tcp_t* handle, struct sockaddr* name, int* namelen)
+
+    Get the address of the peer connected to the handle. `name` must point to
+    a valid and big enough chunk of memory, ``struct sockaddr_storage`` is
+    recommended for IPv4 and IPv6 support.
+
+.. c:function:: int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle, const struct sockaddr* addr, uv_connect_cb cb)
+
+    Establish an IPv4 or IPv6 TCP connection. Provide an initialized TCP handle
+    and an uninitialized :c:type:`uv_connect_t`. `addr` should point to an
+    initialized ``struct sockaddr_in`` or ``struct sockaddr_in6``.
+
+    On Windows if the `addr` is initialized to point to an unspecified address
+    (``0.0.0.0`` or ``::``) it will be changed to point to ``localhost``.
+    This is done to match the behavior of Linux systems.
+
+    The callback is made when the connection has been established or when a
+    connection error happened.
+
+    .. versionchanged:: 1.19.0 added ``0.0.0.0`` and ``::`` to ``localhost``
+        mapping
+
+.. seealso:: The :c:type:`uv_stream_t` API functions also apply.
+
+.. c:function:: int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb)
+
+    Resets a TCP connection by sending a RST packet. This is accomplished by
+    setting the `SO_LINGER` socket option with a linger interval of zero and
+    then calling :c:func:`uv_close`.
+    Due to some platform inconsistencies, mixing of :c:func:`uv_shutdown` and
+    :c:func:`uv_tcp_close_reset` calls is not allowed.
+
+    .. versionadded:: 1.32.0
+
+.. c:function:: int uv_socketpair(int type, int protocol, uv_os_sock_t socket_vector[2], int flags0, int flags1)
+
+    Create a pair of connected sockets with the specified properties.
+    The resulting handles can be passed to `uv_tcp_open`, used with `uv_spawn`,
+    or for any other purpose.
+
+    Valid values for `flags0` and `flags1` are:
+
+      - UV_NONBLOCK_PIPE: Opens the specified socket handle for `OVERLAPPED`
+        or `FIONBIO`/`O_NONBLOCK` I/O usage.
+        This is recommended for handles that will be used by libuv,
+        and not usually recommended otherwise.
+
+    Equivalent to :man:`socketpair(2)` with a domain of AF_UNIX.
+
+    .. versionadded:: 1.41.0

deps/uv/docs/src/threading.rst

@@ -0,0 +1,284 @@
+
+.. _threading:
+
+Threading and synchronization utilities
+=======================================
+
+libuv provides cross-platform implementations for multiple threading and
+synchronization primitives. The API largely follows the pthreads API.
+
+
+Data types
+----------
+
+.. c:type:: uv_thread_t
+
+    Thread data type.
+
+.. c:type:: void (*uv_thread_cb)(void* arg)
+
+    Callback that is invoked to initialize thread execution. `arg` is the same
+    value that was passed to :c:func:`uv_thread_create`.
+
+.. c:type:: uv_key_t
+
+    Thread-local key data type.
+
+.. c:type:: uv_once_t
+
+    Once-only initializer data type.
+
+.. c:type:: uv_mutex_t
+
+    Mutex data type.
+
+.. c:type:: uv_rwlock_t
+
+    Read-write lock data type.
+
+.. c:type:: uv_sem_t
+
+    Semaphore data type.
+
+.. c:type:: uv_cond_t
+
+    Condition data type.
+
+.. c:type:: uv_barrier_t
+
+    Barrier data type.
+
+
+API
+---
+
+Threads
+^^^^^^^
+
+.. c:type:: uv_thread_options_t
+
+    Options for spawning a new thread (passed to :c:func:`uv_thread_create_ex`).
+
+    ::
+
+        typedef struct uv_thread_options_s {
+          enum {
+            UV_THREAD_NO_FLAGS = 0x00,
+            UV_THREAD_HAS_STACK_SIZE = 0x01
+          } flags;
+          size_t stack_size;
+        } uv_thread_options_t;
+
+    More fields may be added to this struct at any time, so its exact
+    layout and size should not be relied upon.
+
+    .. versionadded:: 1.26.0
+
+.. c:function:: int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg)
+
+    .. versionchanged:: 1.4.1 returns a UV_E* error code on failure
+
+.. c:function:: int uv_thread_detach(uv_thread_t* tid)
+
+    Detaches a thread. Detached threads automatically release their
+    resources upon termination, eliminating the need for the application to
+    call `uv_thread_join`.
+
+    .. versionadded:: 1.50.0
+
+.. c:function:: int uv_thread_create_ex(uv_thread_t* tid, const uv_thread_options_t* params, uv_thread_cb entry, void* arg)
+
+    Like :c:func:`uv_thread_create`, but additionally specifies options for creating a new thread.
+
+    If `UV_THREAD_HAS_STACK_SIZE` is set, `stack_size` specifies a stack size for the new thread.
+    `0` indicates that the default value should be used, i.e. behaves as if the flag was not set.
+    Other values will be rounded up to the nearest page boundary.
+
+    .. versionadded:: 1.26.0
+
+.. c:function:: int uv_thread_setaffinity(uv_thread_t* tid, char* cpumask, char* oldmask, size_t mask_size)
+
+    Sets the specified thread's affinity to cpumask, which is specified in
+    bytes. Optionally returning the previous affinity setting in oldmask.
+    On Unix, uses :man:`pthread_getaffinity_np(3)` to get the affinity setting
+    and maps the cpu_set_t to bytes in oldmask. Then maps the bytes in cpumask
+    to a cpu_set_t and uses :man:`pthread_setaffinity_np(3)`. On Windows, maps
+    the bytes in cpumask to a bitmask and uses SetThreadAffinityMask() which
+    returns the previous affinity setting.
+
+    The mask_size specifies the number of entries (bytes) in cpumask / oldmask,
+    and must be greater-than-or-equal-to :c:func:`uv_cpumask_size`.
+
+    .. note::
+        Thread affinity setting is not atomic on Windows. Unsupported on macOS.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: int uv_thread_getaffinity(uv_thread_t* tid, char* cpumask, size_t mask_size)
+
+    Gets the specified thread's affinity setting. On Unix, this maps the
+    cpu_set_t returned by :man:`pthread_getaffinity_np(3)` to bytes in cpumask.
+
+    The mask_size specifies the number of entries (bytes) in cpumask,
+    and must be greater-than-or-equal-to :c:func:`uv_cpumask_size`.
+
+    .. note::
+        Thread affinity getting is not atomic on Windows. Unsupported on macOS.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: int uv_thread_getcpu(void)
+
+    Gets the CPU number on which the calling thread is running.
+
+    .. note::
+        Currently only implemented on Windows, Linux and FreeBSD.
+
+    .. versionadded:: 1.45.0
+
+.. c:function:: uv_thread_t uv_thread_self(void)
+.. c:function:: int uv_thread_join(uv_thread_t *tid)
+.. c:function:: int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2)
+
+.. c:function:: int uv_thread_setname(const char* name)
+
+    Sets the name of the current thread. Different platforms define different limits on the max number of characters
+    a thread name can be: Linux, IBM i (16), macOS (64), Windows (32767), and NetBSD (32), etc. `uv_thread_setname()`
+    will truncate it in case `name` is larger than the limit of the platform.
+
+    Not supported on Windows Server 2016, returns `UV_ENOSYS`.
+
+    .. versionadded:: 1.50.0
+
+.. c:function:: int uv_thread_getname(uv_thread_t* tid, char* name, size_t* size)
+
+    Gets the name of the thread specified by `tid`. The thread name is copied, with the trailing NUL, into the buffer
+    pointed to by `name`. The `size` parameter specifies the size of the buffer pointed to by `name`.
+    The buffer should be large enough to hold the name of the thread plus the trailing NUL, or it will be truncated to fit
+    with the trailing NUL.
+
+    Not supported on Windows Server 2016, returns `UV_ENOSYS`.
+
+    .. versionadded:: 1.50.0
+
+.. c:function:: int uv_thread_setpriority(uv_thread_t tid, int priority)
+
+    If the function succeeds, the return value is 0.
+    If the function fails, the return value is less than zero.
+    Sets the scheduling priority of the thread specified by tid. It requires elevated
+    privilege to set specific priorities on some platforms.
+    The priority can be set to the following constants. UV_THREAD_PRIORITY_HIGHEST, 
+    UV_THREAD_PRIORITY_ABOVE_NORMAL, UV_THREAD_PRIORITY_NORMAL, 
+    UV_THREAD_PRIORITY_BELOW_NORMAL, UV_THREAD_PRIORITY_LOWEST.
+
+.. c:function:: int uv_thread_getpriority(uv_thread_t tid, int* priority)
+
+    If the function succeeds, the return value is 0.
+    If the function fails, the return value is less than zero.
+    Retrieves the scheduling priority of the thread specified by tid. The value in the
+    output parameter priority is platform dependent.
+    For Linux, when schedule policy is SCHED_OTHER (default), priority is 0.
+
+Thread-local storage
+^^^^^^^^^^^^^^^^^^^^
+
+.. note::
+    The total thread-local storage size may be limited. That is, it may not be possible to
+    create many TLS keys.
+
+.. c:function:: int uv_key_create(uv_key_t* key)
+.. c:function:: void uv_key_delete(uv_key_t* key)
+.. c:function:: void* uv_key_get(uv_key_t* key)
+.. c:function:: void uv_key_set(uv_key_t* key, void* value)
+
+Once-only initialization
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Runs a function once and only once. Concurrent calls to :c:func:`uv_once` with the
+same guard will block all callers except one (it's unspecified which one).
+The guard should be initialized statically with the UV_ONCE_INIT macro.
+
+.. c:function:: void uv_once(uv_once_t* guard, void (*callback)(void))
+
+Mutex locks
+^^^^^^^^^^^
+
+Functions return 0 on success or an error code < 0 (unless the
+return type is void, of course).
+
+.. c:function:: int uv_mutex_init(uv_mutex_t* handle)
+.. c:function:: int uv_mutex_init_recursive(uv_mutex_t* handle)
+.. c:function:: void uv_mutex_destroy(uv_mutex_t* handle)
+.. c:function:: void uv_mutex_lock(uv_mutex_t* handle)
+.. c:function:: int uv_mutex_trylock(uv_mutex_t* handle)
+.. c:function:: void uv_mutex_unlock(uv_mutex_t* handle)
+
+Read-write locks
+^^^^^^^^^^^^^^^^
+
+Functions return 0 on success or an error code < 0 (unless the
+return type is void, of course).
+
+.. c:function:: int uv_rwlock_init(uv_rwlock_t* rwlock)
+.. c:function:: void uv_rwlock_destroy(uv_rwlock_t* rwlock)
+.. c:function:: void uv_rwlock_rdlock(uv_rwlock_t* rwlock)
+.. c:function:: int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock)
+.. c:function:: void uv_rwlock_rdunlock(uv_rwlock_t* rwlock)
+.. c:function:: void uv_rwlock_wrlock(uv_rwlock_t* rwlock)
+.. c:function:: int uv_rwlock_trywrlock(uv_rwlock_t* rwlock)
+.. c:function:: void uv_rwlock_wrunlock(uv_rwlock_t* rwlock)
+
+Semaphores
+^^^^^^^^^^
+
+Functions return 0 on success or an error code < 0 (unless the
+return type is void, of course).
+
+.. c:function:: int uv_sem_init(uv_sem_t* sem, unsigned int value)
+.. c:function:: void uv_sem_destroy(uv_sem_t* sem)
+.. c:function:: void uv_sem_post(uv_sem_t* sem)
+.. c:function:: void uv_sem_wait(uv_sem_t* sem)
+.. c:function:: int uv_sem_trywait(uv_sem_t* sem)
+
+Conditions
+^^^^^^^^^^
+
+Functions return 0 on success or an error code < 0 (unless the
+return type is void, of course).
+
+.. note::
+    1. Callers should be prepared to deal with spurious wakeups on :c:func:`uv_cond_wait`
+       and :c:func:`uv_cond_timedwait`.
+    2. The timeout parameter for :c:func:`uv_cond_timedwait` is relative to the time
+       at which function is called.
+    3. On z/OS, the timeout parameter for :c:func:`uv_cond_timedwait` is converted to an
+       absolute system time at which the wait expires. If the current system clock time
+       passes the absolute time calculated before the condition is signaled, an ETIMEDOUT
+       error results. After the wait begins, the wait time is not affected by changes
+       to the system clock.
+
+.. c:function:: int uv_cond_init(uv_cond_t* cond)
+.. c:function:: void uv_cond_destroy(uv_cond_t* cond)
+.. c:function:: void uv_cond_signal(uv_cond_t* cond)
+.. c:function:: void uv_cond_broadcast(uv_cond_t* cond)
+.. c:function:: void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex)
+.. c:function:: int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout)
+
+Barriers
+^^^^^^^^
+
+Functions return 0 on success or an error code < 0 (unless the
+return type is void, of course).
+
+.. note::
+    :c:func:`uv_barrier_wait` returns a value > 0 to an arbitrarily chosen "serializer" thread
+    to facilitate cleanup, i.e.
+
+    ::
+
+        if (uv_barrier_wait(&barrier) > 0)
+            uv_barrier_destroy(&barrier);
+
+.. c:function:: int uv_barrier_init(uv_barrier_t* barrier, unsigned int count)
+.. c:function:: void uv_barrier_destroy(uv_barrier_t* barrier)
+.. c:function:: int uv_barrier_wait(uv_barrier_t* barrier)

deps/uv/docs/src/threadpool.rst

@@ -0,0 +1,74 @@
+
+.. _threadpool:
+
+Thread pool work scheduling
+===========================
+
+libuv provides a threadpool which can be used to run user code and get notified
+in the loop thread. This thread pool is internally used to run all file system
+operations, as well as getaddrinfo and getnameinfo requests.
+
+Its default size is 4, but it can be changed at startup time by setting the
+``UV_THREADPOOL_SIZE`` environment variable to any value (the absolute maximum
+is 1024).
+
+.. versionchanged:: 1.30.0 the maximum UV_THREADPOOL_SIZE allowed was increased from 128 to 1024.
+
+.. versionchanged:: 1.45.0 threads now have an 8 MB stack instead of the
+   (sometimes too low) platform default.
+
+.. versionchanged:: 1.50.0 threads now have a default name of libuv-worker.
+
+The threadpool is global and shared across all event loops. When a particular
+function makes use of the threadpool (e.g. when using :c:func:`uv_queue_work`)
+libuv preallocates and initializes the maximum number of threads allowed by
+``UV_THREADPOOL_SIZE``. More threads usually means more throughput but a higher
+memory footprint. Thread stacks grow lazily on most platforms though.
+
+.. note::
+    Note that even though a global thread pool which is shared across all events
+    loops is used, the functions are not thread safe.
+
+
+Data types
+----------
+
+.. c:type:: uv_work_t
+
+    Work request type.
+
+.. c:type:: void (*uv_work_cb)(uv_work_t* req)
+
+    Callback passed to :c:func:`uv_queue_work` which will be run on the thread
+    pool.
+
+.. c:type:: void (*uv_after_work_cb)(uv_work_t* req, int status)
+
+    Callback passed to :c:func:`uv_queue_work` which will be called on the loop
+    thread after the work on the threadpool has been completed. If the work
+    was cancelled using :c:func:`uv_cancel` `status` will be ``UV_ECANCELED``.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: uv_loop_t* uv_work_t.loop
+
+    Loop that started this request and where completion will be reported.
+    Readonly.
+
+.. seealso:: The :c:type:`uv_req_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb, uv_after_work_cb after_work_cb)
+
+    Initializes a work request which will run the given `work_cb` in a thread
+    from the threadpool. Once `work_cb` is completed, `after_work_cb` will be
+    called on the loop thread.
+
+    This request can be cancelled with :c:func:`uv_cancel`.
+
+.. seealso:: The :c:type:`uv_req_t` API functions also apply.

deps/uv/docs/src/timer.rst

@@ -0,0 +1,92 @@
+
+.. _timer:
+
+:c:type:`uv_timer_t` --- Timer handle
+=====================================
+
+Timer handles are used to schedule callbacks to be called in the future.
+
+Timers are either single-shot or repeating. Repeating timers do not adjust
+for overhead but are rearmed relative to the event loop's idea of "now".
+
+Libuv updates its idea of "now" right before executing timer callbacks, and
+right after waking up from waiting for I/O. See also :c:func:`uv_update_time`.
+
+Example: a repeating timer with a 50 ms interval whose callback takes 17 ms
+to complete, runs again 33 ms later. If other tasks take longer than 33 ms,
+the timer callback runs as soon as possible.
+
+Data types
+----------
+
+.. c:type:: uv_timer_t
+
+    Timer handle type.
+
+.. c:type:: void (*uv_timer_cb)(uv_timer_t* handle)
+
+    Type definition for callback passed to :c:func:`uv_timer_start`.
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle)
+
+    Initialize the handle.
+
+.. c:function:: int uv_timer_start(uv_timer_t* handle, uv_timer_cb cb, uint64_t timeout, uint64_t repeat)
+
+    Start the timer. `timeout` and `repeat` are in milliseconds.
+
+    If `timeout` is zero, the callback fires on the next event loop iteration.
+    If `repeat` is non-zero, the callback fires first after `timeout`
+    milliseconds and then repeatedly after `repeat` milliseconds.
+
+    .. note::
+        Does not update the event loop's concept of "now". See :c:func:`uv_update_time` for more information.
+
+        If the timer is already active, it is simply updated.
+
+.. c:function:: int uv_timer_stop(uv_timer_t* handle)
+
+    Stop the timer, the callback will not be called anymore.
+
+.. c:function:: int uv_timer_again(uv_timer_t* handle)
+
+    Stop the timer, and if it is repeating restart it using the repeat value
+    as the timeout. If the timer has never been started before it returns
+    UV_EINVAL.
+
+.. c:function:: void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat)
+
+    Set the repeat interval value in milliseconds. The timer will be scheduled
+    to run on the given interval, regardless of the callback execution
+    duration, and will follow normal timer semantics in the case of a
+    time-slice overrun.
+
+    .. note::
+        If the repeat value is set from a timer callback it does not immediately take effect.
+        If the timer was non-repeating before, it will have been stopped. If it was repeating,
+        then the old repeat value will have been used to schedule the next timeout.
+
+.. c:function:: uint64_t uv_timer_get_repeat(const uv_timer_t* handle)
+
+    Get the timer repeat value.
+
+.. c:function:: uint64_t uv_timer_get_due_in(const uv_timer_t* handle)
+
+    Get the timer due value or 0 if it has expired. The time is relative to
+    :c:func:`uv_now()`.
+
+    .. versionadded:: 1.40.0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/tty.rst

@@ -0,0 +1,145 @@
+
+.. _tty:
+
+:c:type:`uv_tty_t` --- TTY handle
+=================================
+
+TTY handles represent a stream for the console.
+
+:c:type:`uv_tty_t` is a 'subclass' of :c:type:`uv_stream_t`.
+
+
+Data types
+----------
+
+.. c:type:: uv_tty_t
+
+    TTY handle type.
+
+.. c:enum:: uv_tty_mode_t
+
+    .. versionadded:: 1.2.0
+
+    TTY mode type:
+
+    ::
+
+      typedef enum {
+          /* Initial/normal terminal mode */
+          UV_TTY_MODE_NORMAL,
+          /*
+          * Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled).
+          * May become equivalent to UV_TTY_MODE_RAW_VT in future libuv versions.
+          */
+          UV_TTY_MODE_RAW,
+          /* Binary-safe I/O mode for IPC (Unix-only) */
+          UV_TTY_MODE_IO,
+          /* Raw input mode. On Windows ENABLE_VIRTUAL_TERMINAL_INPUT is also set. */
+          UV_TTY_MODE_RAW_VT
+      } uv_tty_mode_t;
+
+.. c:enum:: uv_tty_vtermstate_t
+
+    Console virtual terminal mode type:
+
+    ::
+
+      typedef enum {
+          /*
+           * The console supports handling of virtual terminal sequences
+           * (Windows10 new console, ConEmu)
+           */
+          UV_TTY_SUPPORTED,
+          /* The console cannot process virtual terminal sequences.  (Legacy
+           * console)
+           */
+          UV_TTY_UNSUPPORTED
+      } uv_tty_vtermstate_t
+
+
+
+Public members
+^^^^^^^^^^^^^^
+
+N/A
+
+.. seealso:: The :c:type:`uv_stream_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_tty_init(uv_loop_t* loop, uv_tty_t* handle, uv_file fd, int unused)
+
+    Initialize a new TTY stream with the given file descriptor. Usually the
+    file descriptor will be:
+
+    * 0 = stdin
+    * 1 = stdout
+    * 2 = stderr
+
+    On Unix this function will determine the path of the fd of the terminal
+    using :man:`ttyname_r(3)`, open it, and use it if the passed file descriptor
+    refers to a TTY. This lets libuv put the tty in non-blocking mode without
+    affecting other processes that share the tty.
+
+    This function is not thread safe on systems that don't support
+    ioctl TIOCGPTN or TIOCPTYGNAME, for instance OpenBSD and Solaris.
+
+    .. note::
+        If reopening the TTY fails, libuv falls back to blocking writes.
+
+    .. versionchanged:: 1.23.1: the `readable` parameter is now unused and ignored.
+                        The correct value will now be auto-detected from the kernel.
+
+    .. versionchanged:: 1.9.0: the path of the TTY is determined by
+                        :man:`ttyname_r(3)`. In earlier versions libuv opened
+                        `/dev/tty` instead.
+
+    .. versionchanged:: 1.5.0: trying to initialize a TTY stream with a file
+                        descriptor that refers to a file returns `UV_EINVAL`
+                        on UNIX.
+
+.. c:function:: int uv_tty_set_mode(uv_tty_t* handle, uv_tty_mode_t mode)
+
+    .. versionchanged:: 1.2.0: the mode is specified as a
+                        :c:enum:`uv_tty_mode_t` value.
+
+    Set the TTY using the specified terminal mode.
+
+.. c:function:: int uv_tty_reset_mode(void)
+
+    To be called when the program exits. Resets TTY settings to default
+    values for the next process to take over.
+
+    This function is async signal-safe on Unix platforms but can fail with error
+    code ``UV_EBUSY`` if you call it when execution is inside
+    :c:func:`uv_tty_set_mode`.
+
+.. c:function:: int uv_tty_get_winsize(uv_tty_t* handle, int* width, int* height)
+
+    Gets the current Window size. On success it returns 0.
+
+.. seealso:: The :c:type:`uv_stream_t` API functions also apply.
+
+.. c:function:: void uv_tty_set_vterm_state(uv_tty_vtermstate_t state)
+
+    Controls whether console virtual terminal sequences are processed by libuv
+    or console.
+    Useful in particular for enabling ConEmu support of ANSI X3.64 and Xterm
+    256 colors. Otherwise Windows10 consoles are usually detected automatically.
+
+    This function is only meaningful on Windows systems. On Unix it is silently
+    ignored.
+
+    .. versionadded:: 1.33.0
+
+.. c:function:: int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state)
+
+    Get the current state of whether console virtual terminal sequences are
+    handled by libuv or the console.
+
+    This function is not implemented on Unix, where it returns ``UV_ENOTSUP``.
+
+    .. versionadded:: 1.33.0
+

deps/uv/docs/src/udp.rst

@@ -0,0 +1,501 @@
+
+.. _udp:
+
+:c:type:`uv_udp_t` --- UDP handle
+=================================
+
+UDP handles encapsulate UDP communication for both clients and servers.
+
+
+Data types
+----------
+
+.. c:type:: uv_udp_t
+
+    UDP handle type.
+
+.. c:type:: uv_udp_send_t
+
+    UDP send request type.
+
+.. c:enum:: uv_udp_flags
+
+    Flags used in :c:func:`uv_udp_bind` and :c:type:`uv_udp_recv_cb`..
+
+    ::
+
+        enum uv_udp_flags {
+            /* Disables dual stack mode. */
+            UV_UDP_IPV6ONLY = 1,
+            /*
+             * Indicates message was truncated because read buffer was too small. The
+             * remainder was discarded by the OS. Used in uv_udp_recv_cb.
+             */
+            UV_UDP_PARTIAL = 2,
+            /*
+             * Indicates if SO_REUSEADDR will be set when binding the handle.
+             * This sets the SO_REUSEPORT socket flag on the BSDs (except for
+             * DragonFlyBSD), OS X, and other platforms where SO_REUSEPORTs don't
+             * have the capability of load balancing, as the opposite of what
+             * UV_UDP_REUSEPORT would do. On other Unix platforms, it sets the
+             * SO_REUSEADDR flag. What that means is that multiple threads or
+             * processes can bind to the same address without error (provided
+             * they all set the flag) but only the last one to bind will receive
+             * any traffic, in effect "stealing" the port from the previous listener.
+             */
+            UV_UDP_REUSEADDR = 4,
+            /*
+             * Indicates that the message was received by recvmmsg, so the buffer provided
+             * must not be freed by the recv_cb callback.
+             */
+            UV_UDP_MMSG_CHUNK = 8,
+            /*
+             * Indicates that the buffer provided has been fully utilized by recvmmsg and
+             * that it should now be freed by the recv_cb callback. When this flag is set
+             * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL.
+             */
+            UV_UDP_MMSG_FREE = 16,
+            /*
+             * Indicates if IP_RECVERR/IPV6_RECVERR will be set when binding the handle.
+             * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on
+             * Linux. This stops the Linux kernel from suppressing some ICMP error messages
+             * and enables full ICMP error reporting for faster failover.
+             * This flag is no-op on platforms other than Linux.
+             */
+            UV_UDP_LINUX_RECVERR = 32,
+            /*
+             * Indicates if SO_REUSEPORT will be set when binding the handle.
+             * This sets the SO_REUSEPORT socket option on supported platforms.
+             * Unlike UV_UDP_REUSEADDR, this flag will make multiple threads or
+             * processes that are binding to the same address and port "share"
+             * the port, which means incoming datagrams are distributed across
+             * the receiving sockets among threads or processes.
+             *
+             * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,
+             * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now.
+             */
+            UV_UDP_REUSEPORT = 64,
+            /*
+             * Indicates that recvmmsg should be used, if available.
+             */
+            UV_UDP_RECVMMSG = 256
+        };
+
+.. c:type:: void (*uv_udp_send_cb)(uv_udp_send_t* req, int status)
+
+    Type definition for callback passed to :c:func:`uv_udp_send`, which is
+    called after the data was sent.
+
+.. c:type:: void (*uv_udp_recv_cb)(uv_udp_t* handle, ssize_t nread, const uv_buf_t* buf, const struct sockaddr* addr, unsigned flags)
+
+    Type definition for callback passed to :c:func:`uv_udp_recv_start`, which
+    is called when the endpoint receives data.
+
+    * `handle`: UDP handle
+    * `nread`:  Number of bytes that have been received.
+      0 if there is no more data to read. Note that 0 may also mean that an
+      empty datagram was received (in this case `addr` is not NULL). < 0 if
+      a transmission error was detected; if using :man:`recvmmsg(2)` no more
+      chunks will be received and the buffer can be freed safely.
+    * `buf`: :c:type:`uv_buf_t` with the received data.
+    * `addr`: ``struct sockaddr*`` containing the address of the sender.
+      Can be NULL. Valid for the duration of the callback only.
+    * `flags`: One or more or'ed UV_UDP_* constants.
+
+    The callee is responsible for freeing the buffer, libuv does not reuse it.
+    The buffer may be a null buffer (where `buf->base` == NULL and `buf->len` == 0)
+    on error.
+
+    When using :man:`recvmmsg(2)`, chunks will have the `UV_UDP_MMSG_CHUNK` flag set,
+    those must not be freed. If no errors occur, there will be a final callback with
+    `nread` set to 0, `addr` set to NULL and the buffer pointing at the initially
+    allocated data with the `UV_UDP_MMSG_CHUNK` flag cleared and the `UV_UDP_MMSG_FREE`
+    flag set. If a UDP socket error occurs, `nread` will be < 0. In either scenario,
+    the callee can now safely free the provided buffer.
+
+    .. versionchanged:: 1.40.0 added the `UV_UDP_MMSG_FREE` flag.
+
+    .. note::
+        The receive callback will be called with `nread` == 0 and `addr` == NULL when there is
+        nothing to read, and with `nread` == 0 and `addr` != NULL when an empty UDP packet is
+        received.
+
+.. c:enum:: uv_membership
+
+    Membership type for a multicast address.
+
+    ::
+
+        typedef enum {
+            UV_LEAVE_GROUP = 0,
+            UV_JOIN_GROUP
+        } uv_membership;
+
+
+Public members
+^^^^^^^^^^^^^^
+
+.. c:member:: size_t uv_udp_t.send_queue_size
+
+    Number of bytes queued for sending. This field strictly shows how much
+    information is currently queued.
+
+.. c:member:: size_t uv_udp_t.send_queue_count
+
+    Number of send requests currently in the queue awaiting to be processed.
+
+.. c:member:: uv_udp_t* uv_udp_send_t.handle
+
+    UDP handle where this send request is taking place.
+
+.. seealso:: The :c:type:`uv_handle_t` members also apply.
+
+
+API
+---
+
+.. c:function:: int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle)
+
+    Initialize a new UDP handle. The actual socket is created lazily.
+    Returns 0 on success.
+
+.. c:function:: int uv_udp_init_ex(uv_loop_t* loop, uv_udp_t* handle, unsigned int flags)
+
+    Initialize the handle with the specified flags. The lower 8 bits of the `flags`
+    parameter are used as the socket domain. A socket will be created for the given domain.
+    If the specified domain is ``AF_UNSPEC`` no socket is created, just like :c:func:`uv_udp_init`.
+
+    The remaining bits can be used to set one of these flags:
+
+    * `UV_UDP_RECVMMSG`: if set, and the platform supports it, :man:`recvmmsg(2)` will
+      be used.
+
+    .. versionadded:: 1.7.0
+    .. versionchanged:: 1.37.0 added the `UV_UDP_RECVMMSG` flag.
+
+.. c:function:: int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock)
+
+    Opens an existing file descriptor or Windows SOCKET as a UDP handle.
+
+    Unix only:
+    The only requirement of the `sock` argument is that it follows the datagram
+    contract (works in unconnected mode, supports sendmsg()/recvmsg(), etc).
+    In other words, other datagram-type sockets like raw sockets or netlink
+    sockets can also be passed to this function.
+
+    .. versionchanged:: 1.2.1 the file descriptor is set to non-blocking mode.
+
+    .. note::
+        The passed file descriptor or SOCKET is not checked for its type, but
+        it's required that it represents a valid datagram socket.
+
+.. c:function:: int uv_udp_bind(uv_udp_t* handle, const struct sockaddr* addr, unsigned int flags)
+
+    Bind the UDP handle to an IP address and port.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param addr: `struct sockaddr_in` or `struct sockaddr_in6`
+        with the address and port to bind to.
+
+    :param flags: Indicate how the socket will be bound,
+        ``UV_UDP_IPV6ONLY``, ``UV_UDP_REUSEADDR``, ``UV_UDP_REUSEPORT``,
+        and ``UV_UDP_RECVERR`` are supported.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. versionchanged:: 1.49.0 added the ``UV_UDP_REUSEPORT`` flag.
+
+    .. note::
+        ``UV_UDP_REUSEPORT`` flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,
+        FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ at the moment. On other platforms
+        this function will return an UV_ENOTSUP error.
+        For platforms where `SO_REUSEPORT`s have the capability of load balancing,
+        specifying both ``UV_UDP_REUSEADDR`` and ``UV_UDP_REUSEPORT`` in flags is allowed
+        and `SO_REUSEPORT` will always override the behavior of `SO_REUSEADDR`.
+        For platforms where `SO_REUSEPORT`s don't have the capability of load balancing,
+        specifying both ``UV_UDP_REUSEADDR`` and ``UV_UDP_REUSEPORT`` in flags will fail,
+        returning an UV_ENOTSUP error.
+
+.. c:function:: int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr)
+
+    Associate the UDP handle to a remote address and port, so every
+    message sent by this handle is automatically sent to that destination.
+    Calling this function with a `NULL` `addr` disconnects the handle.
+    Trying to call `uv_udp_connect()` on an already connected handle will result
+    in an `UV_EISCONN` error. Trying to disconnect a handle that is not
+    connected will return an `UV_ENOTCONN` error.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param addr: `struct sockaddr_in` or `struct sockaddr_in6`
+        with the address and port to associate to.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. versionadded:: 1.27.0
+
+.. c:function:: int uv_udp_getpeername(const uv_udp_t* handle, struct sockaddr* name, int* namelen)
+
+    Get the remote IP and port of the UDP handle on connected UDP handles.
+    On unconnected handles, it returns `UV_ENOTCONN`.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init` and bound.
+
+    :param name: Pointer to the structure to be filled with the address data.
+        In order to support IPv4 and IPv6 `struct sockaddr_storage` should be
+        used.
+
+    :param namelen: On input it indicates the data of the `name` field. On
+        output it indicates how much of it was filled.
+
+    :returns: 0 on success, or an error code < 0 on failure
+
+    .. versionadded:: 1.27.0
+
+.. c:function:: int uv_udp_getsockname(const uv_udp_t* handle, struct sockaddr* name, int* namelen)
+
+    Get the local IP and port of the UDP handle.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init` and bound.
+
+    :param name: Pointer to the structure to be filled with the address data.
+        In order to support IPv4 and IPv6 `struct sockaddr_storage` should be
+        used.
+
+    :param namelen: On input it indicates the data of the `name` field. On
+        output it indicates how much of it was filled.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_membership(uv_udp_t* handle, const char* multicast_addr, const char* interface_addr, uv_membership membership)
+
+    Set membership for a multicast address
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param multicast_addr: Multicast address to set membership for.
+
+    :param interface_addr: Interface address.
+
+    :param membership: Should be ``UV_JOIN_GROUP`` or ``UV_LEAVE_GROUP``.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_source_membership(uv_udp_t* handle, const char* multicast_addr, const char* interface_addr, const char* source_addr, uv_membership membership)
+
+    Set membership for a source-specific multicast group.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param multicast_addr: Multicast address to set membership for.
+
+    :param interface_addr: Interface address.
+
+    :param source_addr: Source address.
+
+    :param membership: Should be ``UV_JOIN_GROUP`` or ``UV_LEAVE_GROUP``.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. versionadded:: 1.32.0
+
+.. c:function:: int uv_udp_set_multicast_loop(uv_udp_t* handle, int on)
+
+    Set IP multicast loop flag. Makes multicast packets loop back to
+    local sockets.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init_ex` as either ``AF_INET`` or ``AF_INET6``, or have
+        been bound to an address explicitly with :c:func:`uv_udp_bind`, or
+        implicitly with :c:func:`uv_udp_send()` or :c:func:`uv_udp_recv_start`.
+
+    :param on: 1 for on, 0 for off.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl)
+
+    Set the multicast ttl.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init_ex` as either ``AF_INET`` or ``AF_INET6``, or have
+        been bound to an address explicitly with :c:func:`uv_udp_bind`, or
+        implicitly with :c:func:`uv_udp_send()` or :c:func:`uv_udp_recv_start`.
+
+    :param ttl: 1 through 255.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_multicast_interface(uv_udp_t* handle, const char* interface_addr)
+
+    Set the multicast interface to send or receive data on.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init_ex` as either ``AF_INET`` or ``AF_INET6``, or have
+        been bound to an address explicitly with :c:func:`uv_udp_bind`, or
+        implicitly with :c:func:`uv_udp_send()` or :c:func:`uv_udp_recv_start`.
+
+    :param interface_addr: interface address.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_broadcast(uv_udp_t* handle, int on)
+
+    Set broadcast on or off.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init_ex` as either ``AF_INET`` or ``AF_INET6``, or have
+        been bound to an address explicitly with :c:func:`uv_udp_bind`, or
+        implicitly with :c:func:`uv_udp_send()` or :c:func:`uv_udp_recv_start`.
+
+    :param on: 1 for on, 0 for off.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_set_ttl(uv_udp_t* handle, int ttl)
+
+    Set the time to live.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init_ex` as either ``AF_INET`` or ``AF_INET6``, or have
+        been bound to an address explicitly with :c:func:`uv_udp_bind`, or
+        implicitly with :c:func:`uv_udp_send()` or :c:func:`uv_udp_recv_start`.
+
+    :param ttl: 1 through 255.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr* addr, uv_udp_send_cb send_cb)
+
+    Send data over the UDP socket. If the socket has not previously been bound
+    with :c:func:`uv_udp_bind` it will be bound to 0.0.0.0
+    (the "all interfaces" IPv4 address) and a random port number.
+
+    On Windows if the `addr` is initialized to point to an unspecified address
+    (``0.0.0.0`` or ``::``) it will be changed to point to ``localhost``.
+    This is done to match the behavior of Linux systems.
+
+    For connected UDP handles, `addr` must be set to `NULL`, otherwise it will
+    return `UV_EISCONN` error.
+
+    For connectionless UDP handles, `addr` cannot be `NULL`, otherwise it will
+    return `UV_EDESTADDRREQ` error.
+
+    :param req: UDP request handle. Need not be initialized.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param bufs: List of buffers to send.
+
+    :param nbufs: Number of buffers in `bufs`.
+
+    :param addr: `struct sockaddr_in` or `struct sockaddr_in6` with the
+        address and port of the remote peer.
+
+    :param send_cb: Callback to invoke when the data has been sent out.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. versionchanged:: 1.19.0 added ``0.0.0.0`` and ``::`` to ``localhost``
+        mapping
+
+    .. versionchanged:: 1.27.0 added support for connected sockets
+
+.. c:function:: int uv_udp_try_send(uv_udp_t* handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr* addr)
+
+    Same as :c:func:`uv_udp_send`, but won't queue a send request if it can't
+    be completed immediately.
+
+    For connected UDP handles, `addr` must be set to `NULL`, otherwise it will
+    return `UV_EISCONN` error.
+
+    For connectionless UDP handles, `addr` cannot be `NULL`, otherwise it will
+    return `UV_EDESTADDRREQ` error.
+
+    :returns: >= 0: number of bytes sent (it matches the given buffer size).
+        < 0: negative error code (``UV_EAGAIN`` is returned when the message
+        can't be sent immediately).
+
+    .. versionchanged:: 1.27.0 added support for connected sockets
+
+.. c:function:: int uv_udp_try_send2(uv_udp_t* handle, unsigned int count, uv_buf_t* bufs[/*count*/], unsigned int nbufs[/*count*/], struct sockaddr* addrs[/*count*/], unsigned int flags)
+
+    Like :c:func:`uv_udp_try_send`, but can send multiple datagrams.
+    Lightweight abstraction around :man:`sendmmsg(2)`, with a :man:`sendmsg(2)`
+    fallback loop for platforms that do not support the former. The handle must
+    be fully initialized; call c:func:`uv_udp_bind` first.
+
+    :returns: >= 0: number of datagrams sent. Zero only if `count` was zero.
+        < 0: negative error code. Only if sending the first datagram fails,
+        otherwise returns a positive send count. ``UV_EAGAIN`` when datagrams
+        cannot be sent right now; fall back to :c:func:`uv_udp_send`.
+
+    .. versionadded:: 1.50.0
+
+.. c:function:: int uv_udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb)
+
+    Prepare for receiving data. If the socket has not previously been bound
+    with :c:func:`uv_udp_bind` it is bound to 0.0.0.0 (the "all interfaces"
+    IPv4 address) and a random port number.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :param alloc_cb: Callback to invoke when temporary storage is needed.
+
+    :param recv_cb: Callback to invoke with received data.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+    .. note::
+        When using :man:`recvmmsg(2)`, the number of messages received at a time is limited
+        by the number of max size dgrams that will fit into the buffer allocated in `alloc_cb`, and
+        `suggested_size` in `alloc_cb` for udp_recv is always set to the size of 1 max size dgram.
+
+    .. versionchanged:: 1.35.0 added support for :man:`recvmmsg(2)` on supported platforms).
+                        The use of this feature requires a buffer larger than
+                        2 * 64KB to be passed to `alloc_cb`.
+    .. versionchanged:: 1.37.0 :man:`recvmmsg(2)` support is no longer enabled implicitly,
+                        it must be explicitly requested by passing the `UV_UDP_RECVMMSG` flag to
+                        :c:func:`uv_udp_init_ex`.
+    .. versionchanged:: 1.39.0 :c:func:`uv_udp_using_recvmmsg` can be used in `alloc_cb` to
+                        determine if a buffer sized for use with :man:`recvmmsg(2)` should be
+                        allocated for the current handle/platform.
+
+.. c:function:: int uv_udp_using_recvmmsg(uv_udp_t* handle)
+
+    Returns 1 if the UDP handle was created with the `UV_UDP_RECVMMSG` flag
+    and the platform supports :man:`recvmmsg(2)`, 0 otherwise.
+
+    .. versionadded:: 1.39.0
+
+.. c:function:: int uv_udp_recv_stop(uv_udp_t* handle)
+
+    Stop listening for incoming datagrams.
+
+    :param handle: UDP handle. Should have been initialized with
+        :c:func:`uv_udp_init`.
+
+    :returns: 0 on success, or an error code < 0 on failure.
+
+.. c:function:: size_t uv_udp_get_send_queue_size(const uv_udp_t* handle)
+
+    Returns `handle->send_queue_size`.
+
+    .. versionadded:: 1.19.0
+
+.. c:function:: size_t uv_udp_get_send_queue_count(const uv_udp_t* handle)
+
+    Returns `handle->send_queue_count`.
+
+    .. versionadded:: 1.19.0
+
+.. seealso:: The :c:type:`uv_handle_t` API functions also apply.

deps/uv/docs/src/upgrading.rst

@@ -0,0 +1,11 @@
+.. _upgrading:
+
+Upgrading
+=========
+
+Migration guides for different libuv versions, starting with 1.0.
+
+.. toctree::
+   :maxdepth: 1
+
+   migration_010_100

deps/uv/docs/src/version.rst

@@ -0,0 +1,60 @@
+
+.. _version:
+
+Version-checking macros and functions
+=====================================
+
+Starting with version 1.0.0 libuv follows the `semantic versioning`_
+scheme. This means that new APIs can be introduced throughout the lifetime of
+a major release. In this section you'll find all macros and functions that
+will allow you to write or compile code conditionally, in order to work with
+multiple libuv versions.
+
+.. _semantic versioning: https://semver.org
+
+
+Macros
+------
+
+.. c:macro:: UV_VERSION_MAJOR
+
+    libuv version's major number.
+
+.. c:macro:: UV_VERSION_MINOR
+
+    libuv version's minor number.
+
+.. c:macro:: UV_VERSION_PATCH
+
+    libuv version's patch number.
+
+.. c:macro:: UV_VERSION_IS_RELEASE
+
+    Set to 1 to indicate a release version of libuv, 0 for a development
+    snapshot.
+
+.. c:macro:: UV_VERSION_SUFFIX
+
+    libuv version suffix. Certain development releases such as Release Candidates
+    might have a suffix such as "rc".
+
+.. c:macro:: UV_VERSION_HEX
+
+    Returns the libuv version packed into a single integer. 8 bits are used for
+    each component, with the patch number stored in the 8 least significant
+    bits. E.g. for libuv 1.2.3 this would be 0x010203.
+
+    .. versionadded:: 1.7.0
+
+
+Functions
+---------
+
+.. c:function:: unsigned int uv_version(void)
+
+    Returns :c:macro:`UV_VERSION_HEX`.
+
+.. c:function:: const char* uv_version_string(void)
+
+    Returns the libuv version number as a string. For non-release versions the
+    version suffix is included.

deps/uv/include/uv/aix.h

@@ -0,0 +1,32 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_AIX_H
+#define UV_AIX_H
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  int fs_fd;                                                                  \
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  uv__io_t event_watcher;                                                     \
+  char *dir_filename;                                                         \
+
+#endif /* UV_AIX_H */

deps/uv/include/uv/bsd.h

@@ -0,0 +1,34 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_BSD_H
+#define UV_BSD_H
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  uv__io_t event_watcher;                                                     \
+
+#define UV_IO_PRIVATE_PLATFORM_FIELDS                                         \
+  int rcount;                                                                 \
+  int wcount;                                                                 \
+
+#define UV_HAVE_KQUEUE 1
+
+#endif /* UV_BSD_H */

deps/uv/include/uv/darwin.h

@@ -0,0 +1,61 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_DARWIN_H
+#define UV_DARWIN_H
+
+#if defined(__APPLE__) && defined(__MACH__)
+# include <mach/mach.h>
+# include <mach/task.h>
+# include <mach/semaphore.h>
+# include <TargetConditionals.h>
+# define UV_PLATFORM_SEM_T semaphore_t
+#endif
+
+#define UV_IO_PRIVATE_PLATFORM_FIELDS                                         \
+  int rcount;                                                                 \
+  int wcount;                                                                 \
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  uv_thread_t cf_thread;                                                      \
+  void* _cf_reserved;                                                         \
+  void* cf_state;                                                             \
+  uv_mutex_t cf_mutex;                                                        \
+  uv_sem_t cf_sem;                                                            \
+  struct uv__queue cf_signals;                                                \
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  uv__io_t event_watcher;                                                     \
+  char* realpath;                                                             \
+  int realpath_len;                                                           \
+  int cf_flags;                                                               \
+  uv_async_t* cf_cb;                                                          \
+  struct uv__queue cf_events;                                                 \
+  struct uv__queue cf_member;                                                 \
+  int cf_error;                                                               \
+  uv_mutex_t cf_mutex;                                                        \
+
+#define UV_STREAM_PRIVATE_PLATFORM_FIELDS                                     \
+  void* select;                                                               \
+
+#define UV_HAVE_KQUEUE 1
+
+#endif /* UV_DARWIN_H */

deps/uv/include/uv/errno.h

@@ -0,0 +1,483 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_ERRNO_H_
+#define UV_ERRNO_H_
+
+#include <errno.h>
+#if EDOM > 0
+# define UV__ERR(x) (-(x))
+#else
+# define UV__ERR(x) (x)
+#endif
+
+#define UV__EOF     (-4095)
+#define UV__UNKNOWN (-4094)
+
+#define UV__EAI_ADDRFAMILY  (-3000)
+#define UV__EAI_AGAIN       (-3001)
+#define UV__EAI_BADFLAGS    (-3002)
+#define UV__EAI_CANCELED    (-3003)
+#define UV__EAI_FAIL        (-3004)
+#define UV__EAI_FAMILY      (-3005)
+#define UV__EAI_MEMORY      (-3006)
+#define UV__EAI_NODATA      (-3007)
+#define UV__EAI_NONAME      (-3008)
+#define UV__EAI_OVERFLOW    (-3009)
+#define UV__EAI_SERVICE     (-3010)
+#define UV__EAI_SOCKTYPE    (-3011)
+#define UV__EAI_BADHINTS    (-3013)
+#define UV__EAI_PROTOCOL    (-3014)
+
+/* Only map to the system errno on non-Windows platforms. It's apparently
+ * a fairly common practice for Windows programmers to redefine errno codes.
+ */
+#if defined(E2BIG) && !defined(_WIN32)
+# define UV__E2BIG UV__ERR(E2BIG)
+#else
+# define UV__E2BIG (-4093)
+#endif
+
+#if defined(EACCES) && !defined(_WIN32)
+# define UV__EACCES UV__ERR(EACCES)
+#else
+# define UV__EACCES (-4092)
+#endif
+
+#if defined(EADDRINUSE) && !defined(_WIN32)
+# define UV__EADDRINUSE UV__ERR(EADDRINUSE)
+#else
+# define UV__EADDRINUSE (-4091)
+#endif
+
+#if defined(EADDRNOTAVAIL) && !defined(_WIN32)
+# define UV__EADDRNOTAVAIL UV__ERR(EADDRNOTAVAIL)
+#else
+# define UV__EADDRNOTAVAIL (-4090)
+#endif
+
+#if defined(EAFNOSUPPORT) && !defined(_WIN32)
+# define UV__EAFNOSUPPORT UV__ERR(EAFNOSUPPORT)
+#else
+# define UV__EAFNOSUPPORT (-4089)
+#endif
+
+#if defined(EAGAIN) && !defined(_WIN32)
+# define UV__EAGAIN UV__ERR(EAGAIN)
+#else
+# define UV__EAGAIN (-4088)
+#endif
+
+#if defined(EALREADY) && !defined(_WIN32)
+# define UV__EALREADY UV__ERR(EALREADY)
+#else
+# define UV__EALREADY (-4084)
+#endif
+
+#if defined(EBADF) && !defined(_WIN32)
+# define UV__EBADF UV__ERR(EBADF)
+#else
+# define UV__EBADF (-4083)
+#endif
+
+#if defined(EBUSY) && !defined(_WIN32)
+# define UV__EBUSY UV__ERR(EBUSY)
+#else
+# define UV__EBUSY (-4082)
+#endif
+
+#if defined(ECANCELED) && !defined(_WIN32)
+# define UV__ECANCELED UV__ERR(ECANCELED)
+#else
+# define UV__ECANCELED (-4081)
+#endif
+
+#if defined(ECHARSET) && !defined(_WIN32)
+# define UV__ECHARSET UV__ERR(ECHARSET)
+#else
+# define UV__ECHARSET (-4080)
+#endif
+
+#if defined(ECONNABORTED) && !defined(_WIN32)
+# define UV__ECONNABORTED UV__ERR(ECONNABORTED)
+#else
+# define UV__ECONNABORTED (-4079)
+#endif
+
+#if defined(ECONNREFUSED) && !defined(_WIN32)
+# define UV__ECONNREFUSED UV__ERR(ECONNREFUSED)
+#else
+# define UV__ECONNREFUSED (-4078)
+#endif
+
+#if defined(ECONNRESET) && !defined(_WIN32)
+# define UV__ECONNRESET UV__ERR(ECONNRESET)
+#else
+# define UV__ECONNRESET (-4077)
+#endif
+
+#if defined(EDESTADDRREQ) && !defined(_WIN32)
+# define UV__EDESTADDRREQ UV__ERR(EDESTADDRREQ)
+#else
+# define UV__EDESTADDRREQ (-4076)
+#endif
+
+#if defined(EEXIST) && !defined(_WIN32)
+# define UV__EEXIST UV__ERR(EEXIST)
+#else
+# define UV__EEXIST (-4075)
+#endif
+
+#if defined(EFAULT) && !defined(_WIN32)
+# define UV__EFAULT UV__ERR(EFAULT)
+#else
+# define UV__EFAULT (-4074)
+#endif
+
+#if defined(EHOSTUNREACH) && !defined(_WIN32)
+# define UV__EHOSTUNREACH UV__ERR(EHOSTUNREACH)
+#else
+# define UV__EHOSTUNREACH (-4073)
+#endif
+
+#if defined(EINTR) && !defined(_WIN32)
+# define UV__EINTR UV__ERR(EINTR)
+#else
+# define UV__EINTR (-4072)
+#endif
+
+#if defined(EINVAL) && !defined(_WIN32)
+# define UV__EINVAL UV__ERR(EINVAL)
+#else
+# define UV__EINVAL (-4071)
+#endif
+
+#if defined(EIO) && !defined(_WIN32)
+# define UV__EIO UV__ERR(EIO)
+#else
+# define UV__EIO (-4070)
+#endif
+
+#if defined(EISCONN) && !defined(_WIN32)
+# define UV__EISCONN UV__ERR(EISCONN)
+#else
+# define UV__EISCONN (-4069)
+#endif
+
+#if defined(EISDIR) && !defined(_WIN32)
+# define UV__EISDIR UV__ERR(EISDIR)
+#else
+# define UV__EISDIR (-4068)
+#endif
+
+#if defined(ELOOP) && !defined(_WIN32)
+# define UV__ELOOP UV__ERR(ELOOP)
+#else
+# define UV__ELOOP (-4067)
+#endif
+
+#if defined(EMFILE) && !defined(_WIN32)
+# define UV__EMFILE UV__ERR(EMFILE)
+#else
+# define UV__EMFILE (-4066)
+#endif
+
+#if defined(EMSGSIZE) && !defined(_WIN32)
+# define UV__EMSGSIZE UV__ERR(EMSGSIZE)
+#else
+# define UV__EMSGSIZE (-4065)
+#endif
+
+#if defined(ENAMETOOLONG) && !defined(_WIN32)
+# define UV__ENAMETOOLONG UV__ERR(ENAMETOOLONG)
+#else
+# define UV__ENAMETOOLONG (-4064)
+#endif
+
+#if defined(ENETDOWN) && !defined(_WIN32)
+# define UV__ENETDOWN UV__ERR(ENETDOWN)
+#else
+# define UV__ENETDOWN (-4063)
+#endif
+
+#if defined(ENETUNREACH) && !defined(_WIN32)
+# define UV__ENETUNREACH UV__ERR(ENETUNREACH)
+#else
+# define UV__ENETUNREACH (-4062)
+#endif
+
+#if defined(ENFILE) && !defined(_WIN32)
+# define UV__ENFILE UV__ERR(ENFILE)
+#else
+# define UV__ENFILE (-4061)
+#endif
+
+#if defined(ENOBUFS) && !defined(_WIN32)
+# define UV__ENOBUFS UV__ERR(ENOBUFS)
+#else
+# define UV__ENOBUFS (-4060)
+#endif
+
+#if defined(ENODEV) && !defined(_WIN32)
+# define UV__ENODEV UV__ERR(ENODEV)
+#else
+# define UV__ENODEV (-4059)
+#endif
+
+#if defined(ENOENT) && !defined(_WIN32)
+# define UV__ENOENT UV__ERR(ENOENT)
+#else
+# define UV__ENOENT (-4058)
+#endif
+
+#if defined(ENOMEM) && !defined(_WIN32)
+# define UV__ENOMEM UV__ERR(ENOMEM)
+#else
+# define UV__ENOMEM (-4057)
+#endif
+
+#if defined(ENONET) && !defined(_WIN32)
+# define UV__ENONET UV__ERR(ENONET)
+#else
+# define UV__ENONET (-4056)
+#endif
+
+#if defined(ENOSPC) && !defined(_WIN32)
+# define UV__ENOSPC UV__ERR(ENOSPC)
+#else
+# define UV__ENOSPC (-4055)
+#endif
+
+#if defined(ENOSYS) && !defined(_WIN32)
+# define UV__ENOSYS UV__ERR(ENOSYS)
+#else
+# define UV__ENOSYS (-4054)
+#endif
+
+#if defined(ENOTCONN) && !defined(_WIN32)
+# define UV__ENOTCONN UV__ERR(ENOTCONN)
+#else
+# define UV__ENOTCONN (-4053)
+#endif
+
+#if defined(ENOTDIR) && !defined(_WIN32)
+# define UV__ENOTDIR UV__ERR(ENOTDIR)
+#else
+# define UV__ENOTDIR (-4052)
+#endif
+
+#if defined(ENOTEMPTY) && !defined(_WIN32)
+# define UV__ENOTEMPTY UV__ERR(ENOTEMPTY)
+#else
+# define UV__ENOTEMPTY (-4051)
+#endif
+
+#if defined(ENOTSOCK) && !defined(_WIN32)
+# define UV__ENOTSOCK UV__ERR(ENOTSOCK)
+#else
+# define UV__ENOTSOCK (-4050)
+#endif
+
+#if defined(ENOTSUP) && !defined(_WIN32)
+# define UV__ENOTSUP UV__ERR(ENOTSUP)
+#else
+# define UV__ENOTSUP (-4049)
+#endif
+
+#if defined(EPERM) && !defined(_WIN32)
+# define UV__EPERM UV__ERR(EPERM)
+#else
+# define UV__EPERM (-4048)
+#endif
+
+#if defined(EPIPE) && !defined(_WIN32)
+# define UV__EPIPE UV__ERR(EPIPE)
+#else
+# define UV__EPIPE (-4047)
+#endif
+
+#if defined(EPROTO) && !defined(_WIN32)
+# define UV__EPROTO UV__ERR(EPROTO)
+#else
+# define UV__EPROTO (-4046)
+#endif
+
+#if defined(EPROTONOSUPPORT) && !defined(_WIN32)
+# define UV__EPROTONOSUPPORT UV__ERR(EPROTONOSUPPORT)
+#else
+# define UV__EPROTONOSUPPORT (-4045)
+#endif
+
+#if defined(EPROTOTYPE) && !defined(_WIN32)
+# define UV__EPROTOTYPE UV__ERR(EPROTOTYPE)
+#else
+# define UV__EPROTOTYPE (-4044)
+#endif
+
+#if defined(EROFS) && !defined(_WIN32)
+# define UV__EROFS UV__ERR(EROFS)
+#else
+# define UV__EROFS (-4043)
+#endif
+
+#if defined(ESHUTDOWN) && !defined(_WIN32)
+# define UV__ESHUTDOWN UV__ERR(ESHUTDOWN)
+#else
+# define UV__ESHUTDOWN (-4042)
+#endif
+
+#if defined(ESPIPE) && !defined(_WIN32)
+# define UV__ESPIPE UV__ERR(ESPIPE)
+#else
+# define UV__ESPIPE (-4041)
+#endif
+
+#if defined(ESRCH) && !defined(_WIN32)
+# define UV__ESRCH UV__ERR(ESRCH)
+#else
+# define UV__ESRCH (-4040)
+#endif
+
+#if defined(ETIMEDOUT) && !defined(_WIN32)
+# define UV__ETIMEDOUT UV__ERR(ETIMEDOUT)
+#else
+# define UV__ETIMEDOUT (-4039)
+#endif
+
+#if defined(ETXTBSY) && !defined(_WIN32)
+# define UV__ETXTBSY UV__ERR(ETXTBSY)
+#else
+# define UV__ETXTBSY (-4038)
+#endif
+
+#if defined(EXDEV) && !defined(_WIN32)
+# define UV__EXDEV UV__ERR(EXDEV)
+#else
+# define UV__EXDEV (-4037)
+#endif
+
+#if defined(EFBIG) && !defined(_WIN32)
+# define UV__EFBIG UV__ERR(EFBIG)
+#else
+# define UV__EFBIG (-4036)
+#endif
+
+#if defined(ENOPROTOOPT) && !defined(_WIN32)
+# define UV__ENOPROTOOPT UV__ERR(ENOPROTOOPT)
+#else
+# define UV__ENOPROTOOPT (-4035)
+#endif
+
+#if defined(ERANGE) && !defined(_WIN32)
+# define UV__ERANGE UV__ERR(ERANGE)
+#else
+# define UV__ERANGE (-4034)
+#endif
+
+#if defined(ENXIO) && !defined(_WIN32)
+# define UV__ENXIO UV__ERR(ENXIO)
+#else
+# define UV__ENXIO (-4033)
+#endif
+
+#if defined(EMLINK) && !defined(_WIN32)
+# define UV__EMLINK UV__ERR(EMLINK)
+#else
+# define UV__EMLINK (-4032)
+#endif
+
+/* EHOSTDOWN is not visible on BSD-like systems when _POSIX_C_SOURCE is
+ * defined. Fortunately, its value is always 64 so it's possible albeit
+ * icky to hard-code it.
+ */
+#if defined(EHOSTDOWN) && !defined(_WIN32)
+# define UV__EHOSTDOWN UV__ERR(EHOSTDOWN)
+#elif defined(__APPLE__) || \
+      defined(__DragonFly__) || \
+      defined(__FreeBSD__) || \
+      defined(__NetBSD__) || \
+      defined(__OpenBSD__)
+# define UV__EHOSTDOWN (-64)
+#else
+# define UV__EHOSTDOWN (-4031)
+#endif
+
+#if defined(EREMOTEIO) && !defined(_WIN32)
+# define UV__EREMOTEIO UV__ERR(EREMOTEIO)
+#else
+# define UV__EREMOTEIO (-4030)
+#endif
+
+#if defined(ENOTTY) && !defined(_WIN32)
+# define UV__ENOTTY UV__ERR(ENOTTY)
+#else
+# define UV__ENOTTY (-4029)
+#endif
+
+#if defined(EFTYPE) && !defined(_WIN32)
+# define UV__EFTYPE UV__ERR(EFTYPE)
+#else
+# define UV__EFTYPE (-4028)
+#endif
+
+#if defined(EILSEQ) && !defined(_WIN32)
+# define UV__EILSEQ UV__ERR(EILSEQ)
+#else
+# define UV__EILSEQ (-4027)
+#endif
+
+#if defined(EOVERFLOW) && !defined(_WIN32)
+# define UV__EOVERFLOW UV__ERR(EOVERFLOW)
+#else
+# define UV__EOVERFLOW (-4026)
+#endif
+
+#if defined(ESOCKTNOSUPPORT) && !defined(_WIN32)
+# define UV__ESOCKTNOSUPPORT UV__ERR(ESOCKTNOSUPPORT)
+#else
+# define UV__ESOCKTNOSUPPORT (-4025)
+#endif
+
+/* FreeBSD defines ENODATA in /usr/include/c++/v1/errno.h which is only visible
+ * if C++ is being used. Define it directly to avoid problems when integrating
+ * libuv in a C++ project.
+ */
+#if defined(ENODATA) && !defined(_WIN32)
+# define UV__ENODATA UV__ERR(ENODATA)
+#elif defined(__FreeBSD__)
+# define UV__ENODATA (-9919)
+#else
+# define UV__ENODATA (-4024)
+#endif
+
+#if defined(EUNATCH) && !defined(_WIN32)
+# define UV__EUNATCH UV__ERR(EUNATCH)
+#else
+# define UV__EUNATCH (-4023)
+#endif
+
+#if defined(ENOEXEC) && !defined(_WIN32)
+# define UV__ENOEXEC UV__ERR(ENOEXEC)
+#else
+# define UV__ENOEXEC (-4022)
+#endif
+
+#endif /* UV_ERRNO_H_ */

deps/uv/include/uv/linux.h

@@ -0,0 +1,34 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_LINUX_H
+#define UV_LINUX_H
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  uv__io_t inotify_read_watcher;                                              \
+  void* inotify_watchers;                                                     \
+  int inotify_fd;                                                             \
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  struct uv__queue watchers;                                                  \
+  int wd;                                                                     \
+
+#endif /* UV_LINUX_H */

deps/uv/include/uv/os390.h

@@ -0,0 +1,33 @@
+/* Copyright libuv project contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_MVS_H
+#define UV_MVS_H
+
+#define UV_PLATFORM_SEM_T long
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  void* ep;                                                                   \
+
+#define UV_PLATFORM_FS_EVENT_FIELDS                                           \
+  char rfis_rftok[8];                                                         \
+
+#endif /* UV_MVS_H */

deps/uv/include/uv/posix.h

@@ -0,0 +1,31 @@
+/* Copyright libuv project contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_POSIX_H
+#define UV_POSIX_H
+
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  struct pollfd* poll_fds;                                                    \
+  size_t poll_fds_used;                                                       \
+  size_t poll_fds_size;                                                       \
+  unsigned char poll_fds_iterating;                                           \
+
+#endif /* UV_POSIX_H */

deps/uv/include/uv/sunos.h

@@ -0,0 +1,44 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_SUNOS_H
+#define UV_SUNOS_H
+
+#include <sys/port.h>
+#include <port.h>
+
+/* For the sake of convenience and reduced #ifdef-ery in src/unix/sunos.c,
+ * add the fs_event fields even when this version of SunOS doesn't support
+ * file watching.
+ */
+#define UV_PLATFORM_LOOP_FIELDS                                               \
+  uv__io_t fs_event_watcher;                                                  \
+  int fs_fd;                                                                  \
+
+#if defined(PORT_SOURCE_FILE)
+
+# define UV_PLATFORM_FS_EVENT_FIELDS                                          \
+  file_obj_t fo;                                                              \
+  int fd;                                                                     \
+
+#endif /* defined(PORT_SOURCE_FILE) */
+
+#endif /* UV_SUNOS_H */

deps/uv/include/uv/threadpool.h

@@ -0,0 +1,37 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/*
+ * This file is private to libuv. It provides common functionality to both
+ * Windows and Unix backends.
+ */
+
+#ifndef UV_THREADPOOL_H_
+#define UV_THREADPOOL_H_
+
+struct uv__work {
+  void (*work)(struct uv__work *w);
+  void (*done)(struct uv__work *w, int status);
+  struct uv_loop_s* loop;
+  struct uv__queue wq;
+};
+
+#endif /* UV_THREADPOOL_H_ */

deps/uv/include/uv/tree.h

@@ -0,0 +1,521 @@
+/*-
+ * Copyright 2002 Niels Provos <provos@citi.umich.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef  UV_TREE_H_
+#define  UV_TREE_H_
+
+#ifndef UV__UNUSED
+# if __GNUC__
+#  define UV__UNUSED __attribute__((unused))
+# else
+#  define UV__UNUSED
+# endif
+#endif
+
+/*
+ * This file defines data structures for red-black trees.
+ * A red-black tree is a binary search tree with the node color as an
+ * extra attribute.  It fulfills a set of conditions:
+ *  - every search path from the root to a leaf consists of the
+ *    same number of black nodes,
+ *  - each red node (except for the root) has a black parent,
+ *  - each leaf node is black.
+ *
+ * Every operation on a red-black tree is bounded as O(lg n).
+ * The maximum height of a red-black tree is 2lg (n+1).
+ */
+
+/* Macros that define a red-black tree */
+#define RB_HEAD(name, type)                                                   \
+struct name {                                                                 \
+  struct type *rbh_root; /* root of the tree */                               \
+}
+
+#define RB_INITIALIZER(root)                                                  \
+  { NULL }
+
+#define RB_INIT(root) do {                                                    \
+  (root)->rbh_root = NULL;                                                    \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_BLACK  0
+#define RB_RED    1
+#define RB_ENTRY(type)                                                        \
+struct {                                                                      \
+  struct type *rbe_left;        /* left element */                            \
+  struct type *rbe_right;       /* right element */                           \
+  struct type *rbe_parent;      /* parent element */                          \
+  int rbe_color;                /* node color */                              \
+}
+
+#define RB_LEFT(elm, field)     (elm)->field.rbe_left
+#define RB_RIGHT(elm, field)    (elm)->field.rbe_right
+#define RB_PARENT(elm, field)   (elm)->field.rbe_parent
+#define RB_COLOR(elm, field)    (elm)->field.rbe_color
+#define RB_ROOT(head)           (head)->rbh_root
+#define RB_EMPTY(head)          (RB_ROOT(head) == NULL)
+
+#define RB_SET(elm, parent, field) do {                                       \
+  RB_PARENT(elm, field) = parent;                                             \
+  RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL;                          \
+  RB_COLOR(elm, field) = RB_RED;                                              \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_SET_BLACKRED(black, red, field) do {                               \
+  RB_COLOR(black, field) = RB_BLACK;                                          \
+  RB_COLOR(red, field) = RB_RED;                                              \
+} while (/*CONSTCOND*/ 0)
+
+#ifndef RB_AUGMENT
+#define RB_AUGMENT(x)  do {} while (0)
+#endif
+
+#define RB_ROTATE_LEFT(head, elm, tmp, field) do {                            \
+  (tmp) = RB_RIGHT(elm, field);                                               \
+  if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) {                 \
+    RB_PARENT(RB_LEFT(tmp, field), field) = (elm);                            \
+  }                                                                           \
+  RB_AUGMENT(elm);                                                            \
+  if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {              \
+    if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                       \
+      RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                          \
+    else                                                                      \
+      RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                         \
+  } else                                                                      \
+    (head)->rbh_root = (tmp);                                                 \
+  RB_LEFT(tmp, field) = (elm);                                                \
+  RB_PARENT(elm, field) = (tmp);                                              \
+  RB_AUGMENT(tmp);                                                            \
+  if ((RB_PARENT(tmp, field)))                                                \
+    RB_AUGMENT(RB_PARENT(tmp, field));                                        \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_ROTATE_RIGHT(head, elm, tmp, field) do {                           \
+  (tmp) = RB_LEFT(elm, field);                                                \
+  if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) {                 \
+    RB_PARENT(RB_RIGHT(tmp, field), field) = (elm);                           \
+  }                                                                           \
+  RB_AUGMENT(elm);                                                            \
+  if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {              \
+    if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                       \
+      RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                          \
+    else                                                                      \
+      RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                         \
+  } else                                                                      \
+    (head)->rbh_root = (tmp);                                                 \
+  RB_RIGHT(tmp, field) = (elm);                                               \
+  RB_PARENT(elm, field) = (tmp);                                              \
+  RB_AUGMENT(tmp);                                                            \
+  if ((RB_PARENT(tmp, field)))                                                \
+    RB_AUGMENT(RB_PARENT(tmp, field));                                        \
+} while (/*CONSTCOND*/ 0)
+
+/* Generates prototypes and inline functions */
+#define  RB_PROTOTYPE(name, type, field, cmp)                                 \
+  RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
+#define  RB_PROTOTYPE_STATIC(name, type, field, cmp)                          \
+  RB_PROTOTYPE_INTERNAL(name, type, field, cmp, UV__UNUSED static)
+#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)                   \
+attr void name##_RB_INSERT_COLOR(struct name *, struct type *);               \
+attr void name##_RB_REMOVE_COLOR(struct name *, struct type *, struct type *);\
+attr struct type *name##_RB_REMOVE(struct name *, struct type *);             \
+attr struct type *name##_RB_INSERT(struct name *, struct type *);             \
+attr struct type *name##_RB_FIND(struct name *, struct type *);               \
+attr struct type *name##_RB_NFIND(struct name *, struct type *);              \
+attr struct type *name##_RB_NEXT(struct type *);                              \
+attr struct type *name##_RB_PREV(struct type *);                              \
+attr struct type *name##_RB_MINMAX(struct name *, int);                       \
+                                                                              \
+
+/* Main rb operation.
+ * Moves node close to the key of elm to top
+ */
+#define  RB_GENERATE(name, type, field, cmp)                                  \
+  RB_GENERATE_INTERNAL(name, type, field, cmp,)
+#define  RB_GENERATE_STATIC(name, type, field, cmp)                           \
+  RB_GENERATE_INTERNAL(name, type, field, cmp, UV__UNUSED static)
+#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr)                    \
+attr void                                                                     \
+name##_RB_INSERT_COLOR(struct name *head, struct type *elm)                   \
+{                                                                             \
+  struct type *parent, *gparent, *tmp;                                        \
+  while ((parent = RB_PARENT(elm, field)) != NULL &&                          \
+      RB_COLOR(parent, field) == RB_RED) {                                    \
+    gparent = RB_PARENT(parent, field);                                       \
+    if (parent == RB_LEFT(gparent, field)) {                                  \
+      tmp = RB_RIGHT(gparent, field);                                         \
+      if (tmp && RB_COLOR(tmp, field) == RB_RED) {                            \
+        RB_COLOR(tmp, field) = RB_BLACK;                                      \
+        RB_SET_BLACKRED(parent, gparent, field);                              \
+        elm = gparent;                                                        \
+        continue;                                                             \
+      }                                                                       \
+      if (RB_RIGHT(parent, field) == elm) {                                   \
+        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
+        tmp = parent;                                                         \
+        parent = elm;                                                         \
+        elm = tmp;                                                            \
+      }                                                                       \
+      RB_SET_BLACKRED(parent, gparent, field);                                \
+      RB_ROTATE_RIGHT(head, gparent, tmp, field);                             \
+    } else {                                                                  \
+      tmp = RB_LEFT(gparent, field);                                          \
+      if (tmp && RB_COLOR(tmp, field) == RB_RED) {                            \
+        RB_COLOR(tmp, field) = RB_BLACK;                                      \
+        RB_SET_BLACKRED(parent, gparent, field);                              \
+        elm = gparent;                                                        \
+        continue;                                                             \
+      }                                                                       \
+      if (RB_LEFT(parent, field) == elm) {                                    \
+        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
+        tmp = parent;                                                         \
+        parent = elm;                                                         \
+        elm = tmp;                                                            \
+      }                                                                       \
+      RB_SET_BLACKRED(parent, gparent, field);                                \
+      RB_ROTATE_LEFT(head, gparent, tmp, field);                              \
+    }                                                                         \
+  }                                                                           \
+  RB_COLOR(head->rbh_root, field) = RB_BLACK;                                 \
+}                                                                             \
+                                                                              \
+attr void                                                                     \
+name##_RB_REMOVE_COLOR(struct name *head, struct type *parent,                \
+    struct type *elm)                                                         \
+{                                                                             \
+  struct type *tmp;                                                           \
+  while ((elm == NULL || RB_COLOR(elm, field) == RB_BLACK) &&                 \
+      elm != RB_ROOT(head)) {                                                 \
+    if (RB_LEFT(parent, field) == elm) {                                      \
+      tmp = RB_RIGHT(parent, field);                                          \
+      if (RB_COLOR(tmp, field) == RB_RED) {                                   \
+        RB_SET_BLACKRED(tmp, parent, field);                                  \
+        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
+        tmp = RB_RIGHT(parent, field);                                        \
+      }                                                                       \
+      if ((RB_LEFT(tmp, field) == NULL ||                                     \
+          RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                \
+          (RB_RIGHT(tmp, field) == NULL ||                                    \
+          RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {               \
+        RB_COLOR(tmp, field) = RB_RED;                                        \
+        elm = parent;                                                         \
+        parent = RB_PARENT(elm, field);                                       \
+      } else {                                                                \
+        if (RB_RIGHT(tmp, field) == NULL ||                                   \
+            RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {              \
+          struct type *oleft;                                                 \
+          if ((oleft = RB_LEFT(tmp, field))                                   \
+              != NULL)                                                        \
+            RB_COLOR(oleft, field) = RB_BLACK;                                \
+          RB_COLOR(tmp, field) = RB_RED;                                      \
+          RB_ROTATE_RIGHT(head, tmp, oleft, field);                           \
+          tmp = RB_RIGHT(parent, field);                                      \
+        }                                                                     \
+        RB_COLOR(tmp, field) = RB_COLOR(parent, field);                       \
+        RB_COLOR(parent, field) = RB_BLACK;                                   \
+        if (RB_RIGHT(tmp, field))                                             \
+          RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK;                   \
+        RB_ROTATE_LEFT(head, parent, tmp, field);                             \
+        elm = RB_ROOT(head);                                                  \
+        break;                                                                \
+      }                                                                       \
+    } else {                                                                  \
+      tmp = RB_LEFT(parent, field);                                           \
+      if (RB_COLOR(tmp, field) == RB_RED) {                                   \
+        RB_SET_BLACKRED(tmp, parent, field);                                  \
+        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
+        tmp = RB_LEFT(parent, field);                                         \
+      }                                                                       \
+      if ((RB_LEFT(tmp, field) == NULL ||                                     \
+          RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                \
+          (RB_RIGHT(tmp, field) == NULL ||                                    \
+          RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {               \
+        RB_COLOR(tmp, field) = RB_RED;                                        \
+        elm = parent;                                                         \
+        parent = RB_PARENT(elm, field);                                       \
+      } else {                                                                \
+        if (RB_LEFT(tmp, field) == NULL ||                                    \
+            RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {               \
+          struct type *oright;                                                \
+          if ((oright = RB_RIGHT(tmp, field))                                 \
+              != NULL)                                                        \
+            RB_COLOR(oright, field) = RB_BLACK;                               \
+          RB_COLOR(tmp, field) = RB_RED;                                      \
+          RB_ROTATE_LEFT(head, tmp, oright, field);                           \
+          tmp = RB_LEFT(parent, field);                                       \
+        }                                                                     \
+        RB_COLOR(tmp, field) = RB_COLOR(parent, field);                       \
+        RB_COLOR(parent, field) = RB_BLACK;                                   \
+        if (RB_LEFT(tmp, field))                                              \
+          RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK;                    \
+        RB_ROTATE_RIGHT(head, parent, tmp, field);                            \
+        elm = RB_ROOT(head);                                                  \
+        break;                                                                \
+      }                                                                       \
+    }                                                                         \
+  }                                                                           \
+  if (elm)                                                                    \
+    RB_COLOR(elm, field) = RB_BLACK;                                          \
+}                                                                             \
+                                                                              \
+attr struct type *                                                            \
+name##_RB_REMOVE(struct name *head, struct type *elm)                         \
+{                                                                             \
+  struct type *child, *parent, *old = elm;                                    \
+  int color;                                                                  \
+  if (RB_LEFT(elm, field) == NULL)                                            \
+    child = RB_RIGHT(elm, field);                                             \
+  else if (RB_RIGHT(elm, field) == NULL)                                      \
+    child = RB_LEFT(elm, field);                                              \
+  else {                                                                      \
+    struct type *left;                                                        \
+    elm = RB_RIGHT(elm, field);                                               \
+    while ((left = RB_LEFT(elm, field)) != NULL)                              \
+      elm = left;                                                             \
+    child = RB_RIGHT(elm, field);                                             \
+    parent = RB_PARENT(elm, field);                                           \
+    color = RB_COLOR(elm, field);                                             \
+    if (child)                                                                \
+      RB_PARENT(child, field) = parent;                                       \
+    if (parent) {                                                             \
+      if (RB_LEFT(parent, field) == elm)                                      \
+        RB_LEFT(parent, field) = child;                                       \
+      else                                                                    \
+        RB_RIGHT(parent, field) = child;                                      \
+      RB_AUGMENT(parent);                                                     \
+    } else                                                                    \
+      RB_ROOT(head) = child;                                                  \
+    if (RB_PARENT(elm, field) == old)                                         \
+      parent = elm;                                                           \
+    (elm)->field = (old)->field;                                              \
+    if (RB_PARENT(old, field)) {                                              \
+      if (RB_LEFT(RB_PARENT(old, field), field) == old)                       \
+        RB_LEFT(RB_PARENT(old, field), field) = elm;                          \
+      else                                                                    \
+        RB_RIGHT(RB_PARENT(old, field), field) = elm;                         \
+      RB_AUGMENT(RB_PARENT(old, field));                                      \
+    } else                                                                    \
+      RB_ROOT(head) = elm;                                                    \
+    RB_PARENT(RB_LEFT(old, field), field) = elm;                              \
+    if (RB_RIGHT(old, field))                                                 \
+      RB_PARENT(RB_RIGHT(old, field), field) = elm;                           \
+    if (parent) {                                                             \
+      left = parent;                                                          \
+      do {                                                                    \
+        RB_AUGMENT(left);                                                     \
+      } while ((left = RB_PARENT(left, field)) != NULL);                      \
+    }                                                                         \
+    goto color;                                                               \
+  }                                                                           \
+  parent = RB_PARENT(elm, field);                                             \
+  color = RB_COLOR(elm, field);                                               \
+  if (child)                                                                  \
+    RB_PARENT(child, field) = parent;                                         \
+  if (parent) {                                                               \
+    if (RB_LEFT(parent, field) == elm)                                        \
+      RB_LEFT(parent, field) = child;                                         \
+    else                                                                      \
+      RB_RIGHT(parent, field) = child;                                        \
+    RB_AUGMENT(parent);                                                       \
+  } else                                                                      \
+    RB_ROOT(head) = child;                                                    \
+color:                                                                        \
+  if (color == RB_BLACK)                                                      \
+    name##_RB_REMOVE_COLOR(head, parent, child);                              \
+  return (old);                                                               \
+}                                                                             \
+                                                                              \
+/* Inserts a node into the RB tree */                                         \
+attr struct type *                                                            \
+name##_RB_INSERT(struct name *head, struct type *elm)                         \
+{                                                                             \
+  struct type *tmp;                                                           \
+  struct type *parent = NULL;                                                 \
+  int comp = 0;                                                               \
+  tmp = RB_ROOT(head);                                                        \
+  while (tmp) {                                                               \
+    parent = tmp;                                                             \
+    comp = (cmp)(elm, parent);                                                \
+    if (comp < 0)                                                             \
+      tmp = RB_LEFT(tmp, field);                                              \
+    else if (comp > 0)                                                        \
+      tmp = RB_RIGHT(tmp, field);                                             \
+    else                                                                      \
+      return (tmp);                                                           \
+  }                                                                           \
+  RB_SET(elm, parent, field);                                                 \
+  if (parent != NULL) {                                                       \
+    if (comp < 0)                                                             \
+      RB_LEFT(parent, field) = elm;                                           \
+    else                                                                      \
+      RB_RIGHT(parent, field) = elm;                                          \
+    RB_AUGMENT(parent);                                                       \
+  } else                                                                      \
+    RB_ROOT(head) = elm;                                                      \
+  name##_RB_INSERT_COLOR(head, elm);                                          \
+  return (NULL);                                                              \
+}                                                                             \
+                                                                              \
+/* Finds the node with the same key as elm */                                 \
+attr struct type *                                                            \
+name##_RB_FIND(struct name *head, struct type *elm)                           \
+{                                                                             \
+  struct type *tmp = RB_ROOT(head);                                           \
+  int comp;                                                                   \
+  while (tmp) {                                                               \
+    comp = cmp(elm, tmp);                                                     \
+    if (comp < 0)                                                             \
+      tmp = RB_LEFT(tmp, field);                                              \
+    else if (comp > 0)                                                        \
+      tmp = RB_RIGHT(tmp, field);                                             \
+    else                                                                      \
+      return (tmp);                                                           \
+  }                                                                           \
+  return (NULL);                                                              \
+}                                                                             \
+                                                                              \
+/* Finds the first node greater than or equal to the search key */            \
+attr struct type *                                                            \
+name##_RB_NFIND(struct name *head, struct type *elm)                          \
+{                                                                             \
+  struct type *tmp = RB_ROOT(head);                                           \
+  struct type *res = NULL;                                                    \
+  int comp;                                                                   \
+  while (tmp) {                                                               \
+    comp = cmp(elm, tmp);                                                     \
+    if (comp < 0) {                                                           \
+      res = tmp;                                                              \
+      tmp = RB_LEFT(tmp, field);                                              \
+    }                                                                         \
+    else if (comp > 0)                                                        \
+      tmp = RB_RIGHT(tmp, field);                                             \
+    else                                                                      \
+      return (tmp);                                                           \
+  }                                                                           \
+  return (res);                                                               \
+}                                                                             \
+                                                                              \
+/* ARGSUSED */                                                                \
+attr struct type *                                                            \
+name##_RB_NEXT(struct type *elm)                                              \
+{                                                                             \
+  if (RB_RIGHT(elm, field)) {                                                 \
+    elm = RB_RIGHT(elm, field);                                               \
+    while (RB_LEFT(elm, field))                                               \
+      elm = RB_LEFT(elm, field);                                              \
+  } else {                                                                    \
+    if (RB_PARENT(elm, field) &&                                              \
+        (elm == RB_LEFT(RB_PARENT(elm, field), field)))                       \
+      elm = RB_PARENT(elm, field);                                            \
+    else {                                                                    \
+      while (RB_PARENT(elm, field) &&                                         \
+          (elm == RB_RIGHT(RB_PARENT(elm, field), field)))                    \
+        elm = RB_PARENT(elm, field);                                          \
+      elm = RB_PARENT(elm, field);                                            \
+    }                                                                         \
+  }                                                                           \
+  return (elm);                                                               \
+}                                                                             \
+                                                                              \
+/* ARGSUSED */                                                                \
+attr struct type *                                                            \
+name##_RB_PREV(struct type *elm)                                              \
+{                                                                             \
+  if (RB_LEFT(elm, field)) {                                                  \
+    elm = RB_LEFT(elm, field);                                                \
+    while (RB_RIGHT(elm, field))                                              \
+      elm = RB_RIGHT(elm, field);                                             \
+  } else {                                                                    \
+    if (RB_PARENT(elm, field) &&                                              \
+        (elm == RB_RIGHT(RB_PARENT(elm, field), field)))                      \
+      elm = RB_PARENT(elm, field);                                            \
+    else {                                                                    \
+      while (RB_PARENT(elm, field) &&                                         \
+          (elm == RB_LEFT(RB_PARENT(elm, field), field)))                     \
+        elm = RB_PARENT(elm, field);                                          \
+      elm = RB_PARENT(elm, field);                                            \
+    }                                                                         \
+  }                                                                           \
+  return (elm);                                                               \
+}                                                                             \
+                                                                              \
+attr struct type *                                                            \
+name##_RB_MINMAX(struct name *head, int val)                                  \
+{                                                                             \
+  struct type *tmp = RB_ROOT(head);                                           \
+  struct type *parent = NULL;                                                 \
+  while (tmp) {                                                               \
+    parent = tmp;                                                             \
+    if (val < 0)                                                              \
+      tmp = RB_LEFT(tmp, field);                                              \
+    else                                                                      \
+      tmp = RB_RIGHT(tmp, field);                                             \
+  }                                                                           \
+  return (parent);                                                            \
+}
+
+#define RB_NEGINF   -1
+#define RB_INF      1
+
+#define RB_INSERT(name, x, y)   name##_RB_INSERT(x, y)
+#define RB_REMOVE(name, x, y)   name##_RB_REMOVE(x, y)
+#define RB_FIND(name, x, y)     name##_RB_FIND(x, y)
+#define RB_NFIND(name, x, y)    name##_RB_NFIND(x, y)
+#define RB_NEXT(name, x)        name##_RB_NEXT(x)
+#define RB_PREV(name, x)        name##_RB_PREV(x)
+#define RB_MIN(name, x)         name##_RB_MINMAX(x, RB_NEGINF)
+#define RB_MAX(name, x)         name##_RB_MINMAX(x, RB_INF)
+
+#define RB_FOREACH(x, name, head)                                             \
+  for ((x) = RB_MIN(name, head);                                              \
+       (x) != NULL;                                                           \
+       (x) = name##_RB_NEXT(x))
+
+#define RB_FOREACH_FROM(x, name, y)                                           \
+  for ((x) = (y);                                                             \
+      ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);                \
+       (x) = (y))
+
+#define RB_FOREACH_SAFE(x, name, head, y)                                     \
+  for ((x) = RB_MIN(name, head);                                              \
+      ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);                \
+       (x) = (y))
+
+#define RB_FOREACH_REVERSE(x, name, head)                                     \
+  for ((x) = RB_MAX(name, head);                                              \
+       (x) != NULL;                                                           \
+       (x) = name##_RB_PREV(x))
+
+#define RB_FOREACH_REVERSE_FROM(x, name, y)                                   \
+  for ((x) = (y);                                                             \
+      ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);                \
+       (x) = (y))
+
+#define RB_FOREACH_REVERSE_SAFE(x, name, head, y)                             \
+  for ((x) = RB_MAX(name, head);                                              \
+      ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);                \
+       (x) = (y))
+
+#endif  /* UV_TREE_H_ */

deps/uv/include/uv/unix.h

@@ -0,0 +1,512 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_UNIX_H
+#define UV_UNIX_H
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>  /* MAXHOSTNAMELEN on Solaris */
+
+#include <termios.h>
+#include <pwd.h>
+
+#if !defined(__MVS__)
+#include <semaphore.h>
+#include <sys/param.h> /* MAXHOSTNAMELEN on Linux and the BSDs */
+#endif
+#include <pthread.h>
+#include <signal.h>
+
+#include "uv/threadpool.h"
+
+#if defined(__linux__)
+# include "uv/linux.h"
+#elif defined (__MVS__)
+# include "uv/os390.h"
+#elif defined(__PASE__)  /* __PASE__ and _AIX are both defined on IBM i */
+# include "uv/posix.h"  /* IBM i needs uv/posix.h, not uv/aix.h */
+#elif defined(_AIX)
+# include "uv/aix.h"
+#elif defined(__sun)
+# include "uv/sunos.h"
+#elif defined(__APPLE__)
+# include "uv/darwin.h"
+#elif defined(__DragonFly__)       || \
+      defined(__FreeBSD__)         || \
+      defined(__OpenBSD__)         || \
+      defined(__NetBSD__)
+# include "uv/bsd.h"
+#elif defined(__CYGWIN__) || \
+      defined(__MSYS__)   || \
+      defined(__HAIKU__)  || \
+      defined(__QNX__)    || \
+      defined(__GNU__)
+# include "uv/posix.h"
+#endif
+
+#ifndef NI_MAXHOST
+# define NI_MAXHOST 1025
+#endif
+
+#ifndef NI_MAXSERV
+# define NI_MAXSERV 32
+#endif
+
+#ifndef UV_IO_PRIVATE_PLATFORM_FIELDS
+# define UV_IO_PRIVATE_PLATFORM_FIELDS /* empty */
+#endif
+
+struct uv__io_s;
+struct uv_loop_s;
+
+typedef void (*uv__io_cb)(struct uv_loop_s* loop,
+                          struct uv__io_s* w,
+                          unsigned int events);
+typedef struct uv__io_s uv__io_t;
+
+struct uv__io_s {
+  uv__io_cb cb;
+  struct uv__queue pending_queue;
+  struct uv__queue watcher_queue;
+  unsigned int pevents; /* Pending event mask i.e. mask at next tick. */
+  unsigned int events;  /* Current event mask. */
+  int fd;
+  UV_IO_PRIVATE_PLATFORM_FIELDS
+};
+
+#ifndef UV_PLATFORM_SEM_T
+# define UV_PLATFORM_SEM_T sem_t
+#endif
+
+#ifndef UV_PLATFORM_LOOP_FIELDS
+# define UV_PLATFORM_LOOP_FIELDS /* empty */
+#endif
+
+#ifndef UV_PLATFORM_FS_EVENT_FIELDS
+# define UV_PLATFORM_FS_EVENT_FIELDS /* empty */
+#endif
+
+#ifndef UV_STREAM_PRIVATE_PLATFORM_FIELDS
+# define UV_STREAM_PRIVATE_PLATFORM_FIELDS /* empty */
+#endif
+
+/* Note: May be cast to struct iovec. See writev(2). */
+typedef struct uv_buf_t {
+  char* base;
+  size_t len;
+} uv_buf_t;
+
+typedef int uv_file;
+typedef int uv_os_sock_t;
+typedef int uv_os_fd_t;
+typedef pid_t uv_pid_t;
+
+#define UV_ONCE_INIT PTHREAD_ONCE_INIT
+
+typedef pthread_once_t uv_once_t;
+typedef pthread_t uv_thread_t;
+typedef pthread_mutex_t uv_mutex_t;
+typedef pthread_rwlock_t uv_rwlock_t;
+typedef UV_PLATFORM_SEM_T uv_sem_t;
+typedef pthread_cond_t uv_cond_t;
+typedef pthread_key_t uv_key_t;
+
+/* Note: guard clauses should match uv_barrier_init's in src/unix/thread.c. */
+#if defined(_AIX) || \
+    defined(__OpenBSD__) || \
+    !defined(PTHREAD_BARRIER_SERIAL_THREAD)
+/* TODO(bnoordhuis) Merge into uv_barrier_t in v2. */
+struct _uv_barrier {
+  uv_mutex_t mutex;
+  uv_cond_t cond;
+  unsigned threshold;
+  unsigned in;
+  unsigned out;
+};
+
+typedef struct {
+  struct _uv_barrier* b;
+# if defined(PTHREAD_BARRIER_SERIAL_THREAD)
+  /* TODO(bnoordhuis) Remove padding in v2. */
+  char pad[sizeof(pthread_barrier_t) - sizeof(struct _uv_barrier*)];
+# endif
+} uv_barrier_t;
+#else
+typedef pthread_barrier_t uv_barrier_t;
+#endif
+
+/* Platform-specific definitions for uv_spawn support. */
+typedef gid_t uv_gid_t;
+typedef uid_t uv_uid_t;
+
+typedef struct dirent uv__dirent_t;
+
+#define UV_DIR_PRIVATE_FIELDS \
+  DIR* dir;
+
+#if defined(DT_UNKNOWN)
+# define HAVE_DIRENT_TYPES
+# if defined(DT_REG)
+#  define UV__DT_FILE DT_REG
+# else
+#  define UV__DT_FILE -1
+# endif
+# if defined(DT_DIR)
+#  define UV__DT_DIR DT_DIR
+# else
+#  define UV__DT_DIR -2
+# endif
+# if defined(DT_LNK)
+#  define UV__DT_LINK DT_LNK
+# else
+#  define UV__DT_LINK -3
+# endif
+# if defined(DT_FIFO)
+#  define UV__DT_FIFO DT_FIFO
+# else
+#  define UV__DT_FIFO -4
+# endif
+# if defined(DT_SOCK)
+#  define UV__DT_SOCKET DT_SOCK
+# else
+#  define UV__DT_SOCKET -5
+# endif
+# if defined(DT_CHR)
+#  define UV__DT_CHAR DT_CHR
+# else
+#  define UV__DT_CHAR -6
+# endif
+# if defined(DT_BLK)
+#  define UV__DT_BLOCK DT_BLK
+# else
+#  define UV__DT_BLOCK -7
+# endif
+#endif
+
+/* Platform-specific definitions for uv_dlopen support. */
+#define UV_DYNAMIC /* empty */
+
+typedef struct {
+  void* handle;
+  char* errmsg;
+} uv_lib_t;
+
+#define UV_LOOP_PRIVATE_FIELDS                                                \
+  unsigned long flags;                                                        \
+  int backend_fd;                                                             \
+  struct uv__queue pending_queue;                                             \
+  struct uv__queue watcher_queue;                                             \
+  uv__io_t** watchers;                                                        \
+  unsigned int nwatchers;                                                     \
+  unsigned int nfds;                                                          \
+  struct uv__queue wq;                                                        \
+  uv_mutex_t wq_mutex;                                                        \
+  uv_async_t wq_async;                                                        \
+  uv_rwlock_t cloexec_lock;                                                   \
+  uv_handle_t* closing_handles;                                               \
+  struct uv__queue process_handles;                                           \
+  struct uv__queue prepare_handles;                                           \
+  struct uv__queue check_handles;                                             \
+  struct uv__queue idle_handles;                                              \
+  struct uv__queue async_handles;                                             \
+  void (*async_unused)(void);  /* TODO(bnoordhuis) Remove in libuv v2. */     \
+  uv__io_t async_io_watcher;                                                  \
+  int async_wfd;                                                              \
+  struct {                                                                    \
+    void* min;                                                                \
+    unsigned int nelts;                                                       \
+  } timer_heap;                                                               \
+  uint64_t timer_counter;                                                     \
+  uint64_t time;                                                              \
+  int signal_pipefd[2];                                                       \
+  uv__io_t signal_io_watcher;                                                 \
+  uv_signal_t child_watcher;                                                  \
+  int emfile_fd;                                                              \
+  UV_PLATFORM_LOOP_FIELDS                                                     \
+
+#define UV_REQ_TYPE_PRIVATE /* empty */
+
+#define UV_REQ_PRIVATE_FIELDS  /* empty */
+
+#define UV_PRIVATE_REQ_TYPES /* empty */
+
+#define UV_WRITE_PRIVATE_FIELDS                                               \
+  struct uv__queue queue;                                                     \
+  unsigned int write_index;                                                   \
+  uv_buf_t* bufs;                                                             \
+  unsigned int nbufs;                                                         \
+  int error;                                                                  \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_CONNECT_PRIVATE_FIELDS                                             \
+  struct uv__queue queue;                                                     \
+
+#define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */
+
+#define UV_UDP_SEND_PRIVATE_FIELDS                                            \
+  struct uv__queue queue;                                                     \
+  union {                                                                     \
+    struct sockaddr addr;                                                     \
+    struct sockaddr_storage storage;                                          \
+  } u;                                                                        \
+  unsigned int nbufs;                                                         \
+  uv_buf_t* bufs;                                                             \
+  ssize_t status;                                                             \
+  uv_udp_send_cb send_cb;                                                     \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_HANDLE_PRIVATE_FIELDS                                              \
+  uv_handle_t* next_closing;                                                  \
+  unsigned int flags;                                                         \
+
+#define UV_STREAM_PRIVATE_FIELDS                                              \
+  uv_connect_t *connect_req;                                                  \
+  uv_shutdown_t *shutdown_req;                                                \
+  uv__io_t io_watcher;                                                        \
+  struct uv__queue write_queue;                                               \
+  struct uv__queue write_completed_queue;                                     \
+  uv_connection_cb connection_cb;                                             \
+  int delayed_error;                                                          \
+  int accepted_fd;                                                            \
+  void* queued_fds;                                                           \
+  UV_STREAM_PRIVATE_PLATFORM_FIELDS                                           \
+
+#define UV_TCP_PRIVATE_FIELDS /* empty */
+
+#define UV_UDP_PRIVATE_FIELDS                                                 \
+  uv_alloc_cb alloc_cb;                                                       \
+  uv_udp_recv_cb recv_cb;                                                     \
+  uv__io_t io_watcher;                                                        \
+  struct uv__queue write_queue;                                               \
+  struct uv__queue write_completed_queue;                                     \
+
+#define UV_PIPE_PRIVATE_FIELDS                                                \
+  const char* pipe_fname; /* NULL or strdup'ed */
+
+#define UV_POLL_PRIVATE_FIELDS                                                \
+  uv__io_t io_watcher;
+
+#define UV_PREPARE_PRIVATE_FIELDS                                             \
+  uv_prepare_cb prepare_cb;                                                   \
+  struct uv__queue queue;                                                     \
+
+#define UV_CHECK_PRIVATE_FIELDS                                               \
+  uv_check_cb check_cb;                                                       \
+  struct uv__queue queue;                                                     \
+
+#define UV_IDLE_PRIVATE_FIELDS                                                \
+  uv_idle_cb idle_cb;                                                         \
+  struct uv__queue queue;                                                     \
+
+#define UV_ASYNC_PRIVATE_FIELDS                                               \
+  uv_async_cb async_cb;                                                       \
+  struct uv__queue queue;                                                     \
+  int pending;                                                                \
+
+#define UV_TIMER_PRIVATE_FIELDS                                               \
+  uv_timer_cb timer_cb;                                                       \
+  union {                                                                     \
+    void* heap[3];                                                            \
+    struct uv__queue queue;                                                   \
+  } node;                                                                     \
+  uint64_t timeout;                                                           \
+  uint64_t repeat;                                                            \
+  uint64_t start_id;
+
+#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getaddrinfo_cb cb;                                                       \
+  struct addrinfo* hints;                                                     \
+  char* hostname;                                                             \
+  char* service;                                                              \
+  struct addrinfo* addrinfo;                                                  \
+  int retcode;
+
+#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getnameinfo_cb getnameinfo_cb;                                           \
+  struct sockaddr_storage storage;                                            \
+  int flags;                                                                  \
+  char host[NI_MAXHOST];                                                      \
+  char service[NI_MAXSERV];                                                   \
+  int retcode;
+
+#define UV_PROCESS_PRIVATE_FIELDS                                             \
+  struct uv__queue queue;                                                     \
+  int status;                                                                 \
+
+#define UV_FS_PRIVATE_FIELDS                                                  \
+  const char *new_path;                                                       \
+  uv_file file;                                                               \
+  int flags;                                                                  \
+  mode_t mode;                                                                \
+  unsigned int nbufs;                                                         \
+  uv_buf_t* bufs;                                                             \
+  off_t off;                                                                  \
+  uv_uid_t uid;                                                               \
+  uv_gid_t gid;                                                               \
+  double atime;                                                               \
+  double mtime;                                                               \
+  struct uv__work work_req;                                                   \
+  uv_buf_t bufsml[4];                                                         \
+
+#define UV_WORK_PRIVATE_FIELDS                                                \
+  struct uv__work work_req;
+
+#define UV_TTY_PRIVATE_FIELDS                                                 \
+  struct termios orig_termios;                                                \
+  int mode;
+
+#define UV_SIGNAL_PRIVATE_FIELDS                                              \
+  /* RB_ENTRY(uv_signal_s) tree_entry; */                                     \
+  struct {                                                                    \
+    struct uv_signal_s* rbe_left;                                             \
+    struct uv_signal_s* rbe_right;                                            \
+    struct uv_signal_s* rbe_parent;                                           \
+    int rbe_color;                                                            \
+  } tree_entry;                                                               \
+  /* Use two counters here so we don have to fiddle with atomics. */          \
+  unsigned int caught_signals;                                                \
+  unsigned int dispatched_signals;
+
+#define UV_FS_EVENT_PRIVATE_FIELDS                                            \
+  uv_fs_event_cb cb;                                                          \
+  UV_PLATFORM_FS_EVENT_FIELDS                                                 \
+
+/* fs open() flags supported on this platform: */
+#if defined(O_APPEND)
+# define UV_FS_O_APPEND       O_APPEND
+#else
+# define UV_FS_O_APPEND       0
+#endif
+#if defined(O_CREAT)
+# define UV_FS_O_CREAT        O_CREAT
+#else
+# define UV_FS_O_CREAT        0
+#endif
+
+#if defined(__linux__) && defined(__arm__)
+# define UV_FS_O_DIRECT       0x10000
+#elif defined(__linux__) && defined(__m68k__)
+# define UV_FS_O_DIRECT       0x10000
+#elif defined(__linux__) && defined(__mips__)
+# define UV_FS_O_DIRECT       0x08000
+#elif defined(__linux__) && defined(__powerpc__)
+# define UV_FS_O_DIRECT       0x20000
+#elif defined(__linux__) && defined(__s390x__)
+# define UV_FS_O_DIRECT       0x04000
+#elif defined(__linux__) && defined(__x86_64__)
+# define UV_FS_O_DIRECT       0x04000
+#elif defined(__linux__) && defined(__loongarch__)
+# define UV_FS_O_DIRECT       0x04000
+#elif defined(O_DIRECT)
+# define UV_FS_O_DIRECT       O_DIRECT
+#else
+# define UV_FS_O_DIRECT       0
+#endif
+
+#if defined(O_DIRECTORY)
+# define UV_FS_O_DIRECTORY    O_DIRECTORY
+#else
+# define UV_FS_O_DIRECTORY    0
+#endif
+#if defined(O_DSYNC)
+# define UV_FS_O_DSYNC        O_DSYNC
+#else
+# define UV_FS_O_DSYNC        0
+#endif
+#if defined(O_EXCL)
+# define UV_FS_O_EXCL         O_EXCL
+#else
+# define UV_FS_O_EXCL         0
+#endif
+#if defined(O_EXLOCK)
+# define UV_FS_O_EXLOCK       O_EXLOCK
+#else
+# define UV_FS_O_EXLOCK       0
+#endif
+#if defined(O_NOATIME)
+# define UV_FS_O_NOATIME      O_NOATIME
+#else
+# define UV_FS_O_NOATIME      0
+#endif
+#if defined(O_NOCTTY)
+# define UV_FS_O_NOCTTY       O_NOCTTY
+#else
+# define UV_FS_O_NOCTTY       0
+#endif
+#if defined(O_NOFOLLOW)
+# define UV_FS_O_NOFOLLOW     O_NOFOLLOW
+#else
+# define UV_FS_O_NOFOLLOW     0
+#endif
+#if defined(O_NONBLOCK)
+# define UV_FS_O_NONBLOCK     O_NONBLOCK
+#else
+# define UV_FS_O_NONBLOCK     0
+#endif
+#if defined(O_RDONLY)
+# define UV_FS_O_RDONLY       O_RDONLY
+#else
+# define UV_FS_O_RDONLY       0
+#endif
+#if defined(O_RDWR)
+# define UV_FS_O_RDWR         O_RDWR
+#else
+# define UV_FS_O_RDWR         0
+#endif
+#if defined(O_SYMLINK)
+# define UV_FS_O_SYMLINK      O_SYMLINK
+#else
+# define UV_FS_O_SYMLINK      0
+#endif
+#if defined(O_SYNC)
+# define UV_FS_O_SYNC         O_SYNC
+#else
+# define UV_FS_O_SYNC         0
+#endif
+#if defined(O_TRUNC)
+# define UV_FS_O_TRUNC        O_TRUNC
+#else
+# define UV_FS_O_TRUNC        0
+#endif
+#if defined(O_WRONLY)
+# define UV_FS_O_WRONLY       O_WRONLY
+#else
+# define UV_FS_O_WRONLY       0
+#endif
+
+/* fs open() flags supported on other platforms: */
+#define UV_FS_O_FILEMAP       0
+#define UV_FS_O_RANDOM        0
+#define UV_FS_O_SHORT_LIVED   0
+#define UV_FS_O_SEQUENTIAL    0
+#define UV_FS_O_TEMPORARY     0
+
+#endif /* UV_UNIX_H */

deps/uv/include/uv/version.h

@@ -0,0 +1,43 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_VERSION_H
+#define UV_VERSION_H
+
+ /*
+ * Versions with the same major number are ABI stable. API is allowed to
+ * evolve between minor releases, but only in a backwards compatible way.
+ * Make sure you update the -soname directives in configure.ac
+ * whenever you bump UV_VERSION_MAJOR or UV_VERSION_MINOR (but
+ * not UV_VERSION_PATCH.)
+ */
+
+#define UV_VERSION_MAJOR 1
+#define UV_VERSION_MINOR 51
+#define UV_VERSION_PATCH 0
+#define UV_VERSION_IS_RELEASE 1
+#define UV_VERSION_SUFFIX ""
+
+#define UV_VERSION_HEX  ((UV_VERSION_MAJOR << 16) | \
+                         (UV_VERSION_MINOR <<  8) | \
+                         (UV_VERSION_PATCH))
+
+#endif /* UV_VERSION_H */

deps/uv/include/uv/win.h

@@ -0,0 +1,698 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef _WIN32_WINNT
+# define _WIN32_WINNT   0x0A00
+#endif
+
+#if !defined(_SSIZE_T_) && !defined(_SSIZE_T_DEFINED)
+typedef intptr_t ssize_t;
+# define SSIZE_MAX INTPTR_MAX
+# define _SSIZE_T_
+# define _SSIZE_T_DEFINED
+#endif
+
+#include <winsock2.h>
+
+#ifndef LOCALE_INVARIANT
+# define LOCALE_INVARIANT 0x007f
+#endif
+
+#include <mswsock.h>
+/* Disable the typedef in mstcpip.h of MinGW. */
+#define _TCP_INITIAL_RTO_PARAMETERS _TCP_INITIAL_RTO_PARAMETERS__AVOID
+#define TCP_INITIAL_RTO_PARAMETERS TCP_INITIAL_RTO_PARAMETERS__AVOID
+#define PTCP_INITIAL_RTO_PARAMETERS PTCP_INITIAL_RTO_PARAMETERS__AVOID
+#include <ws2tcpip.h>
+#undef _TCP_INITIAL_RTO_PARAMETERS
+#undef TCP_INITIAL_RTO_PARAMETERS
+#undef PTCP_INITIAL_RTO_PARAMETERS
+#include <windows.h>
+
+#include <process.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <stdint.h>
+
+#include "uv/tree.h"
+#include "uv/threadpool.h"
+
+#define MAX_PIPENAME_LEN 256
+
+#ifndef S_IFLNK
+# define S_IFLNK 0xA000
+#endif
+
+/* Define missing in Windows Kit Include\{VERSION}\ucrt\sys\stat.h */
+#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES && !defined(S_IFIFO)
+# define S_IFIFO _S_IFIFO
+#endif
+
+/* Additional signals supported by uv_signal and or uv_kill. The CRT defines
+ * the following signals already:
+ *
+ *   #define SIGINT           2
+ *   #define SIGILL           4
+ *   #define SIGABRT_COMPAT   6
+ *   #define SIGFPE           8
+ *   #define SIGSEGV         11
+ *   #define SIGTERM         15
+ *   #define SIGBREAK        21
+ *   #define SIGABRT         22
+ *
+ * The additional signals have values that are common on other Unix
+ * variants (Linux and Darwin)
+ */
+#define SIGHUP                1
+#define SIGQUIT               3
+#define SIGKILL               9
+#define SIGWINCH             28
+
+/* Redefine NSIG to take SIGWINCH into consideration */
+#if defined(NSIG) && NSIG <= SIGWINCH
+# undef NSIG
+#endif
+#ifndef NSIG
+# define NSIG SIGWINCH + 1
+#endif
+
+/* The CRT defines SIGABRT_COMPAT as 6, which equals SIGABRT on many unix-like
+ * platforms. However MinGW doesn't define it, so we do. */
+#ifndef SIGABRT_COMPAT
+# define SIGABRT_COMPAT       6
+#endif
+
+/*
+ * Guids and typedefs for winsock extension functions
+ * Mingw32 doesn't have these :-(
+ */
+#ifndef WSAID_ACCEPTEX
+# define WSAID_ACCEPTEX                                                       \
+         {0xb5367df1, 0xcbac, 0x11cf,                                         \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+# define WSAID_CONNECTEX                                                      \
+         {0x25a207b9, 0xddf3, 0x4660,                                         \
+         {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}
+
+# define WSAID_GETACCEPTEXSOCKADDRS                                           \
+         {0xb5367df2, 0xcbac, 0x11cf,                                         \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+# define WSAID_DISCONNECTEX                                                   \
+         {0x7fda2e11, 0x8630, 0x436f,                                         \
+         {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}
+
+# define WSAID_TRANSMITFILE                                                   \
+         {0xb5367df0, 0xcbac, 0x11cf,                                         \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+  typedef BOOL (PASCAL *LPFN_ACCEPTEX)
+                      (SOCKET sListenSocket,
+                       SOCKET sAcceptSocket,
+                       PVOID lpOutputBuffer,
+                       DWORD dwReceiveDataLength,
+                       DWORD dwLocalAddressLength,
+                       DWORD dwRemoteAddressLength,
+                       LPDWORD lpdwBytesReceived,
+                       LPOVERLAPPED lpOverlapped);
+
+  typedef BOOL (PASCAL *LPFN_CONNECTEX)
+                      (SOCKET s,
+                       const struct sockaddr* name,
+                       int namelen,
+                       PVOID lpSendBuffer,
+                       DWORD dwSendDataLength,
+                       LPDWORD lpdwBytesSent,
+                       LPOVERLAPPED lpOverlapped);
+
+  typedef void (PASCAL *LPFN_GETACCEPTEXSOCKADDRS)
+                      (PVOID lpOutputBuffer,
+                       DWORD dwReceiveDataLength,
+                       DWORD dwLocalAddressLength,
+                       DWORD dwRemoteAddressLength,
+                       LPSOCKADDR* LocalSockaddr,
+                       LPINT LocalSockaddrLength,
+                       LPSOCKADDR* RemoteSockaddr,
+                       LPINT RemoteSockaddrLength);
+
+  typedef BOOL (PASCAL *LPFN_DISCONNECTEX)
+                      (SOCKET hSocket,
+                       LPOVERLAPPED lpOverlapped,
+                       DWORD dwFlags,
+                       DWORD reserved);
+
+  typedef BOOL (PASCAL *LPFN_TRANSMITFILE)
+                      (SOCKET hSocket,
+                       HANDLE hFile,
+                       DWORD nNumberOfBytesToWrite,
+                       DWORD nNumberOfBytesPerSend,
+                       LPOVERLAPPED lpOverlapped,
+                       LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
+                       DWORD dwFlags);
+
+  typedef PVOID RTL_SRWLOCK;
+  typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
+#endif
+
+typedef int (WSAAPI* LPFN_WSARECV)
+            (SOCKET socket,
+             LPWSABUF buffers,
+             DWORD buffer_count,
+             LPDWORD bytes,
+             LPDWORD flags,
+             LPWSAOVERLAPPED overlapped,
+             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
+
+typedef int (WSAAPI* LPFN_WSARECVFROM)
+            (SOCKET socket,
+             LPWSABUF buffers,
+             DWORD buffer_count,
+             LPDWORD bytes,
+             LPDWORD flags,
+             struct sockaddr* addr,
+             LPINT addr_len,
+             LPWSAOVERLAPPED overlapped,
+             LPWSAOVERLAPPED_COMPLETION_ROUTINE completion_routine);
+
+#ifndef _NTDEF_
+  typedef LONG NTSTATUS;
+  typedef NTSTATUS *PNTSTATUS;
+#endif
+
+#ifndef RTL_CONDITION_VARIABLE_INIT
+  typedef PVOID CONDITION_VARIABLE, *PCONDITION_VARIABLE;
+#endif
+
+typedef struct _AFD_POLL_HANDLE_INFO {
+  HANDLE Handle;
+  ULONG Events;
+  NTSTATUS Status;
+} AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO;
+
+typedef struct _AFD_POLL_INFO {
+  LARGE_INTEGER Timeout;
+  ULONG NumberOfHandles;
+  ULONG Exclusive;
+  AFD_POLL_HANDLE_INFO Handles[1];
+} AFD_POLL_INFO, *PAFD_POLL_INFO;
+
+#define UV_MSAFD_PROVIDER_COUNT 4
+
+
+/**
+ * It should be possible to cast uv_buf_t[] to WSABUF[]
+ * see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx
+ */
+typedef struct uv_buf_t {
+  ULONG len;
+  char* base;
+} uv_buf_t;
+
+typedef int uv_file;
+typedef SOCKET uv_os_sock_t;
+typedef HANDLE uv_os_fd_t;
+typedef int uv_pid_t;
+
+typedef HANDLE uv_thread_t;
+
+typedef HANDLE uv_sem_t;
+
+typedef CRITICAL_SECTION uv_mutex_t;
+
+/* This condition variable implementation is based on the SetEvent solution
+ * (section 3.2) at http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
+ * We could not use the SignalObjectAndWait solution (section 3.4) because
+ * it want the 2nd argument (type uv_mutex_t) of uv_cond_wait() and
+ * uv_cond_timedwait() to be HANDLEs, but we use CRITICAL_SECTIONs.
+ */
+
+typedef union {
+  CONDITION_VARIABLE cond_var;
+  struct {
+    unsigned int waiters_count;
+    CRITICAL_SECTION waiters_count_lock;
+    HANDLE signal_event;
+    HANDLE broadcast_event;
+  } unused_; /* TODO: retained for ABI compatibility; remove me in v2.x. */
+} uv_cond_t;
+
+typedef struct {
+  SRWLOCK read_write_lock_;
+  /* TODO: retained for ABI compatibility; remove me in v2.x */
+#ifdef _WIN64
+  unsigned char padding_[72];
+#else
+  unsigned char padding_[44];
+#endif
+} uv_rwlock_t;
+
+typedef struct {
+  unsigned threshold;
+  unsigned in;
+  uv_mutex_t mutex;
+  /* TODO: in v2 make this a uv_cond_t, without unused_ */
+  CONDITION_VARIABLE cond;
+  unsigned out;
+} uv_barrier_t;
+
+typedef struct {
+  DWORD tls_index;
+} uv_key_t;
+
+#define UV_ONCE_INIT { 0, NULL }
+
+typedef struct uv_once_s {
+  unsigned char unused;
+  INIT_ONCE init_once;
+} uv_once_t;
+
+/* Platform-specific definitions for uv_spawn support. */
+typedef unsigned char uv_uid_t;
+typedef unsigned char uv_gid_t;
+
+typedef struct uv__dirent_s {
+  int d_type;
+  char d_name[1];
+} uv__dirent_t;
+
+#define UV_DIR_PRIVATE_FIELDS \
+  HANDLE dir_handle;          \
+  WIN32_FIND_DATAW find_data; \
+  BOOL need_find_call;
+
+#define HAVE_DIRENT_TYPES
+#define UV__DT_DIR     UV_DIRENT_DIR
+#define UV__DT_FILE    UV_DIRENT_FILE
+#define UV__DT_LINK    UV_DIRENT_LINK
+#define UV__DT_FIFO    UV_DIRENT_FIFO
+#define UV__DT_SOCKET  UV_DIRENT_SOCKET
+#define UV__DT_CHAR    UV_DIRENT_CHAR
+#define UV__DT_BLOCK   UV_DIRENT_BLOCK
+
+/* Platform-specific definitions for uv_dlopen support. */
+#define UV_DYNAMIC FAR WINAPI
+typedef struct {
+  HMODULE handle;
+  char* errmsg;
+} uv_lib_t;
+
+#define UV_LOOP_PRIVATE_FIELDS                                                \
+    /* The loop's I/O completion port */                                      \
+  HANDLE iocp;                                                                \
+  /* The current time according to the event loop. in msecs. */               \
+  uint64_t time;                                                              \
+  /* Tail of a single-linked circular queue of pending reqs. If the queue */  \
+  /* is empty, tail_ is NULL. If there is only one item, */                   \
+  /* tail_->next_req == tail_ */                                              \
+  uv_req_t* pending_reqs_tail;                                                \
+  /* Head of a single-linked list of closed handles */                        \
+  uv_handle_t* endgame_handles;                                               \
+  /* TODO(bnoordhuis) Stop heap-allocating |timer_heap| in libuv v2.x. */     \
+  void* timer_heap;                                                           \
+    /* Lists of active loop (prepare / check / idle) watchers */              \
+  uv_prepare_t* prepare_handles;                                              \
+  uv_check_t* check_handles;                                                  \
+  uv_idle_t* idle_handles;                                                    \
+  /* This pointer will refer to the prepare/check/idle handle whose */        \
+  /* callback is scheduled to be called next. This is needed to allow */      \
+  /* safe removal from one of the lists above while that list being */        \
+  /* iterated over. */                                                        \
+  uv_prepare_t* next_prepare_handle;                                          \
+  uv_check_t* next_check_handle;                                              \
+  uv_idle_t* next_idle_handle;                                                \
+  /* This handle holds the peer sockets for the fast variant of uv_poll_t */  \
+  SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT];                          \
+  /* No longer used. */                                                       \
+  unsigned int active_tcp_streams;                                            \
+  /* No longer used. */                                                       \
+  unsigned int active_udp_streams;                                            \
+  /* Counter to started timer */                                              \
+  uint64_t timer_counter;                                                     \
+  /* Threadpool */                                                            \
+  struct uv__queue wq;                                                        \
+  uv_mutex_t wq_mutex;                                                        \
+  uv_async_t wq_async;
+
+#define UV_REQ_TYPE_PRIVATE                                                   \
+  /* TODO: remove the req suffix */                                           \
+  UV_ACCEPT,                                                                  \
+  UV_FS_EVENT_REQ,                                                            \
+  UV_POLL_REQ,                                                                \
+  UV_PROCESS_EXIT,                                                            \
+  UV_READ,                                                                    \
+  UV_UDP_RECV,                                                                \
+  UV_WAKEUP,                                                                  \
+  UV_SIGNAL_REQ,
+
+#define UV_REQ_PRIVATE_FIELDS                                                 \
+  union {                                                                     \
+    /* Used by I/O operations */                                              \
+    struct {                                                                  \
+      OVERLAPPED overlapped;                                                  \
+      size_t queued_bytes;                                                    \
+    } io;                                                                     \
+    /* in v2, we can move these to the UV_CONNECT_PRIVATE_FIELDS */           \
+    struct {                                                                  \
+      ULONG_PTR result; /* overlapped.Internal is reused to hold the result */\
+      HANDLE pipeHandle;                                                      \
+      DWORD duplex_flags;                                                     \
+      WCHAR* name;                                                             \
+    } connect;                                                                \
+  } u;                                                                        \
+  struct uv_req_s* next_req;
+
+#define UV_WRITE_PRIVATE_FIELDS \
+  int coalesced;                \
+  uv_buf_t write_buffer;        \
+  HANDLE event_handle;          \
+  HANDLE wait_handle;
+
+#define UV_CONNECT_PRIVATE_FIELDS                                             \
+  /* empty */
+
+#define UV_SHUTDOWN_PRIVATE_FIELDS                                            \
+  /* empty */
+
+#define UV_UDP_SEND_PRIVATE_FIELDS                                            \
+  /* empty */
+
+#define UV_PRIVATE_REQ_TYPES                                                  \
+  typedef struct uv_pipe_accept_s {                                           \
+    UV_REQ_FIELDS                                                             \
+    HANDLE pipeHandle;                                                        \
+    struct uv_pipe_accept_s* next_pending;                                    \
+  } uv_pipe_accept_t;                                                         \
+                                                                              \
+  typedef struct uv_tcp_accept_s {                                            \
+    UV_REQ_FIELDS                                                             \
+    SOCKET accept_socket;                                                     \
+    char accept_buffer[sizeof(struct sockaddr_storage) * 2 + 32];             \
+    HANDLE event_handle;                                                      \
+    HANDLE wait_handle;                                                       \
+    struct uv_tcp_accept_s* next_pending;                                     \
+  } uv_tcp_accept_t;                                                          \
+                                                                              \
+  typedef struct uv_read_s {                                                  \
+    UV_REQ_FIELDS                                                             \
+    HANDLE event_handle;                                                      \
+    HANDLE wait_handle;                                                       \
+  } uv_read_t;
+
+#define uv_stream_connection_fields                                           \
+  unsigned int write_reqs_pending;                                            \
+  uv_shutdown_t* shutdown_req;
+
+#define uv_stream_server_fields                                               \
+  uv_connection_cb connection_cb;
+
+#define UV_STREAM_PRIVATE_FIELDS                                              \
+  unsigned int reqs_pending;                                                  \
+  int activecnt;                                                              \
+  uv_read_t read_req;                                                         \
+  union {                                                                     \
+    struct { uv_stream_connection_fields } conn;                              \
+    struct { uv_stream_server_fields     } serv;                              \
+  } stream;
+
+#define uv_tcp_server_fields                                                  \
+  uv_tcp_accept_t* accept_reqs;                                               \
+  unsigned int processed_accepts;                                             \
+  uv_tcp_accept_t* pending_accepts;                                           \
+  LPFN_ACCEPTEX func_acceptex;
+
+#define uv_tcp_connection_fields                                              \
+  uv_buf_t read_buffer;                                                       \
+  LPFN_CONNECTEX func_connectex;
+
+#define UV_TCP_PRIVATE_FIELDS                                                 \
+  SOCKET socket;                                                              \
+  int delayed_error;                                                          \
+  union {                                                                     \
+    struct { uv_tcp_server_fields } serv;                                     \
+    struct { uv_tcp_connection_fields } conn;                                 \
+  } tcp;
+
+#define UV_UDP_PRIVATE_FIELDS                                                 \
+  SOCKET socket;                                                              \
+  unsigned int reqs_pending;                                                  \
+  int activecnt;                                                              \
+  uv_req_t recv_req;                                                          \
+  uv_buf_t recv_buffer;                                                       \
+  struct sockaddr_storage recv_from;                                          \
+  int recv_from_len;                                                          \
+  uv_udp_recv_cb recv_cb;                                                     \
+  uv_alloc_cb alloc_cb;                                                       \
+  LPFN_WSARECV func_wsarecv;                                                  \
+  LPFN_WSARECVFROM func_wsarecvfrom;
+
+#define uv_pipe_server_fields                                                 \
+  int pending_instances;                                                      \
+  uv_pipe_accept_t* accept_reqs;                                              \
+  uv_pipe_accept_t* pending_accepts;
+
+#define uv_pipe_connection_fields                                             \
+  uv_timer_t* eof_timer;                                                      \
+  uv_write_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
+  DWORD ipc_remote_pid;                                                       \
+  union {                                                                     \
+    uint32_t payload_remaining;                                               \
+    uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \
+  } ipc_data_frame;                                                           \
+  struct uv__queue ipc_xfer_queue;                                            \
+  int ipc_xfer_queue_length;                                                  \
+  uv_write_t* non_overlapped_writes_tail;                                     \
+  CRITICAL_SECTION readfile_thread_lock;                                      \
+  volatile HANDLE readfile_thread_handle;
+
+#define UV_PIPE_PRIVATE_FIELDS                                                \
+  HANDLE handle;                                                              \
+  WCHAR* name;                                                                \
+  union {                                                                     \
+    struct { uv_pipe_server_fields } serv;                                    \
+    struct { uv_pipe_connection_fields } conn;                                \
+  } pipe;
+
+/* TODO: put the parser states in a union - TTY handles are always half-duplex
+ * so read-state can safely overlap write-state. */
+#define UV_TTY_PRIVATE_FIELDS                                                 \
+  HANDLE handle;                                                              \
+  union {                                                                     \
+    struct {                                                                  \
+      /* Used for readable TTY handles */                                     \
+      union {                                                                 \
+        /* TODO: remove me in v2.x. */                                        \
+        HANDLE unused_;                                                       \
+        int mode;                                                             \
+      } mode;                                                                 \
+      uv_buf_t read_line_buffer;                                              \
+      HANDLE read_raw_wait;                                                   \
+      /* Fields used for translating win keystrokes into vt100 characters */  \
+      char last_key[8];                                                       \
+      unsigned char last_key_offset;                                          \
+      unsigned char last_key_len;                                             \
+      WCHAR last_utf16_high_surrogate;                                        \
+      INPUT_RECORD last_input_record;                                         \
+    } rd;                                                                     \
+    struct {                                                                  \
+      /* Used for writable TTY handles */                                     \
+      /* utf8-to-utf16 conversion state */                                    \
+      unsigned int utf8_codepoint;                                            \
+      unsigned char utf8_bytes_left;                                          \
+      /* eol conversion state */                                              \
+      unsigned char previous_eol;                                             \
+      /* ansi parser state */                                                 \
+      unsigned short ansi_parser_state;                                       \
+      unsigned char ansi_csi_argc;                                            \
+      unsigned short ansi_csi_argv[4];                                        \
+      COORD saved_position;                                                   \
+      WORD saved_attributes;                                                  \
+    } wr;                                                                     \
+  } tty;
+
+#define UV_POLL_PRIVATE_FIELDS                                                \
+  SOCKET socket;                                                              \
+  /* Used in fast mode */                                                     \
+  SOCKET peer_socket;                                                         \
+  AFD_POLL_INFO afd_poll_info_1;                                              \
+  AFD_POLL_INFO afd_poll_info_2;                                              \
+  /* Used in fast and slow mode. */                                           \
+  uv_req_t poll_req_1;                                                        \
+  uv_req_t poll_req_2;                                                        \
+  unsigned char submitted_events_1;                                           \
+  unsigned char submitted_events_2;                                           \
+  unsigned char mask_events_1;                                                \
+  unsigned char mask_events_2;                                                \
+  unsigned char events;
+
+#define UV_TIMER_PRIVATE_FIELDS                                               \
+  union {                                                                     \
+    void* heap[3];                                                            \
+    struct uv__queue queue;                                                   \
+  } node;                                                                     \
+  int unused;                                                                 \
+  uint64_t timeout;                                                           \
+  uint64_t repeat;                                                            \
+  uint64_t start_id;                                                          \
+  uv_timer_cb timer_cb;
+
+#define UV_ASYNC_PRIVATE_FIELDS                                               \
+  struct uv_req_s async_req;                                                  \
+  uv_async_cb async_cb;                                                       \
+  /* char to avoid alignment issues */                                        \
+  char volatile async_sent;
+
+#define UV_PREPARE_PRIVATE_FIELDS                                             \
+  uv_prepare_t* prepare_prev;                                                 \
+  uv_prepare_t* prepare_next;                                                 \
+  uv_prepare_cb prepare_cb;
+
+#define UV_CHECK_PRIVATE_FIELDS                                               \
+  uv_check_t* check_prev;                                                     \
+  uv_check_t* check_next;                                                     \
+  uv_check_cb check_cb;
+
+#define UV_IDLE_PRIVATE_FIELDS                                                \
+  uv_idle_t* idle_prev;                                                       \
+  uv_idle_t* idle_next;                                                       \
+  uv_idle_cb idle_cb;
+
+#define UV_HANDLE_PRIVATE_FIELDS                                              \
+  uv_handle_t* endgame_next;                                                  \
+  unsigned int flags;
+
+#define UV_GETADDRINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getaddrinfo_cb getaddrinfo_cb;                                           \
+  void* alloc;                                                                \
+  WCHAR* node;                                                                \
+  WCHAR* service;                                                             \
+  /* The addrinfoW field is used to store a pointer to the hints, and    */   \
+  /* later on to store the result of GetAddrInfoW. The final result will */   \
+  /* be converted to struct addrinfo* and stored in the addrinfo field.  */   \
+  struct addrinfoW* addrinfow;                                                \
+  struct addrinfo* addrinfo;                                                  \
+  int retcode;
+
+#define UV_GETNAMEINFO_PRIVATE_FIELDS                                         \
+  struct uv__work work_req;                                                   \
+  uv_getnameinfo_cb getnameinfo_cb;                                           \
+  struct sockaddr_storage storage;                                            \
+  int flags;                                                                  \
+  char host[NI_MAXHOST];                                                      \
+  char service[NI_MAXSERV];                                                   \
+  int retcode;
+
+#define UV_PROCESS_PRIVATE_FIELDS                                             \
+  struct uv_process_exit_s {                                                  \
+    UV_REQ_FIELDS                                                             \
+  } exit_req;                                                                 \
+  void* unused; /* TODO: retained for ABI compat; remove this in v2.x. */     \
+  int exit_signal;                                                            \
+  HANDLE wait_handle;                                                         \
+  HANDLE process_handle;                                                      \
+  volatile char exit_cb_pending;
+
+#define UV_FS_PRIVATE_FIELDS                                                  \
+  struct uv__work work_req;                                                   \
+  int flags;                                                                  \
+  DWORD sys_errno_;                                                           \
+  union {                                                                     \
+    /* TODO: remove me in 0.9. */                                             \
+    WCHAR* pathw;                                                             \
+    int fd;                                                                   \
+  } file;                                                                     \
+  union {                                                                     \
+    struct {                                                                  \
+      int mode;                                                               \
+      WCHAR* new_pathw;                                                       \
+      int file_flags;                                                         \
+      int fd_out;                                                             \
+      unsigned int nbufs;                                                     \
+      uv_buf_t* bufs;                                                         \
+      int64_t offset;                                                         \
+      uv_buf_t bufsml[4];                                                     \
+    } info;                                                                   \
+    struct {                                                                  \
+      double atime;                                                           \
+      double mtime;                                                           \
+    } time;                                                                   \
+  } fs;
+
+#define UV_WORK_PRIVATE_FIELDS                                                \
+  struct uv__work work_req;
+
+#define UV_FS_EVENT_PRIVATE_FIELDS                                            \
+  struct uv_fs_event_req_s {                                                  \
+    UV_REQ_FIELDS                                                             \
+  } req;                                                                      \
+  HANDLE dir_handle;                                                          \
+  int req_pending;                                                            \
+  uv_fs_event_cb cb;                                                          \
+  WCHAR* filew;                                                               \
+  WCHAR* short_filew;                                                         \
+  WCHAR* dirw;                                                                \
+  char* buffer;
+
+#define UV_SIGNAL_PRIVATE_FIELDS                                              \
+  RB_ENTRY(uv_signal_s) tree_entry;                                           \
+  struct uv_req_s signal_req;                                                 \
+  unsigned long pending_signum;
+
+#ifndef F_OK
+#define F_OK 0
+#endif
+#ifndef R_OK
+#define R_OK 4
+#endif
+#ifndef W_OK
+#define W_OK 2
+#endif
+#ifndef X_OK
+#define X_OK 1
+#endif
+
+/* fs open() flags supported on this platform: */
+#define UV_FS_O_APPEND       _O_APPEND
+#define UV_FS_O_CREAT        _O_CREAT
+#define UV_FS_O_EXCL         _O_EXCL
+#define UV_FS_O_FILEMAP      0x20000000
+#define UV_FS_O_RANDOM       _O_RANDOM
+#define UV_FS_O_RDONLY       _O_RDONLY
+#define UV_FS_O_RDWR         _O_RDWR
+#define UV_FS_O_SEQUENTIAL   _O_SEQUENTIAL
+#define UV_FS_O_SHORT_LIVED  _O_SHORT_LIVED
+#define UV_FS_O_TEMPORARY    _O_TEMPORARY
+#define UV_FS_O_TRUNC        _O_TRUNC
+#define UV_FS_O_WRONLY       _O_WRONLY
+
+/* fs open() flags supported on other platforms (or mapped on this platform): */
+#define UV_FS_O_DIRECT       0x02000000 /* FILE_FLAG_NO_BUFFERING */
+#define UV_FS_O_DIRECTORY    0
+#define UV_FS_O_DSYNC        0x04000000 /* FILE_FLAG_WRITE_THROUGH */
+#define UV_FS_O_EXLOCK       0x10000000 /* EXCLUSIVE SHARING MODE */
+#define UV_FS_O_NOATIME      0
+#define UV_FS_O_NOCTTY       0
+#define UV_FS_O_NOFOLLOW     0
+#define UV_FS_O_NONBLOCK     0
+#define UV_FS_O_SYMLINK      0
+#define UV_FS_O_SYNC         0x08000000 /* FILE_FLAG_WRITE_THROUGH */

deps/uv/libuv-static.pc.in

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=${prefix}
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libuv-static
+Version: @PACKAGE_VERSION@
+Description: multi-platform support library with a focus on asynchronous I/O.
+URL: http://libuv.org/
+
+Libs: -L${libdir} -l:libuv.a @LIBS@
+Cflags: -I${includedir}

deps/uv/libuv.pc.in

@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=${prefix}
+libdir=@libdir@
+includedir=@includedir@
+LIBUV_STATIC=-L${libdir} -l:libuv.a @LIBS@
+
+Name: libuv
+Version: @PACKAGE_VERSION@
+Description: multi-platform support library with a focus on asynchronous I/O.
+URL: http://libuv.org/
+
+Libs: -L${libdir} -luv @LIBS@
+Cflags: -I${includedir}

deps/uv/m4/.gitignore

@@ -0,0 +1,5 @@
+# Ignore libtoolize-generated files.
+*.m4
+!as_case.m4
+!ax_pthread.m4
+!libuv-check-flags.m4

deps/uv/m4/as_case.m4

@@ -0,0 +1,21 @@
+# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT])
+# ----------------------------------------------------
+# Expand into
+# | case WORD in
+# | PATTERN1) IF-MATCHED1 ;;
+# | ...
+# | *) DEFAULT ;;
+# | esac
+m4_define([_AS_CASE],
+[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])],
+       [$#], 1, [  *) $1 ;;],
+       [$#], 2, [  $1) m4_default([$2], [:]) ;;],
+       [  $1) m4_default([$2], [:]) ;;
+$0(m4_shiftn(2, $@))])dnl
+])
+m4_defun([AS_CASE],
+[m4_ifval([$2$3],
+[case $1 in
+_AS_CASE(m4_shift($@))
+esac])])
+

deps/uv/m4/ax_pthread.m4

@@ -0,0 +1,485 @@
+# ===========================================================================
+#        https://www.gnu.org/software/autoconf-archive/ax_pthread.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+#   This macro figures out how to build C programs using POSIX threads. It
+#   sets the PTHREAD_LIBS output variable to the threads library and linker
+#   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
+#   flags that are needed. (The user can also force certain compiler
+#   flags/libs to be tested by setting these environment variables.)
+#
+#   Also sets PTHREAD_CC to any special C compiler that is needed for
+#   multi-threaded programs (defaults to the value of CC otherwise). (This
+#   is necessary on AIX to use the special cc_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also to link with them as well. For example, you might link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threaded programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to
+#   that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+#   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
+#   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
+#   PTHREAD_CFLAGS.
+#
+#   ACTION-IF-FOUND is a list of shell commands to run if a threads library
+#   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
+#   is not found. If ACTION-IF-FOUND is not specified, the default action
+#   will define HAVE_PTHREAD.
+#
+#   Please let the authors know if this macro fails on any platform, or if
+#   you have any other suggestions or comments. This macro was based on work
+#   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
+#   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
+#   Alejandro Forero Cuervo to the autoconf macro repository. We are also
+#   grateful for the helpful feedback of numerous users.
+#
+#   Updated for Autoconf 2.68 by Daniel Richard G.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 24
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_REQUIRE([AC_PROG_CC])
+AC_REQUIRE([AC_PROG_SED])
+AC_LANG_PUSH([C])
+ax_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on Tru64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then
+        ax_pthread_save_CC="$CC"
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"])
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS])
+        AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes])
+        AC_MSG_RESULT([$ax_pthread_ok])
+        if test "x$ax_pthread_ok" = "xno"; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        CC="$ax_pthread_save_CC"
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try.  Items starting with a "-" are
+# C compiler flags, and other items are library names, except for "none"
+# which indicates that we try without any flags at all, and "pthread-config"
+# which is a program returning the flags for the Pth emulation library.
+
+ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64
+#           (Note: HP C rejects this with "bad form for `-t' option")
+# -pthreads: Solaris/gcc (Note: HP C also rejects)
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads and
+#      -D_REENTRANT too), HP C (must be checked before -lpthread, which
+#      is present but should not be used directly; and before -mthreads,
+#      because the compiler interprets this as "-mt" + "-hreads")
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case $host_os in
+
+        freebsd*)
+
+        # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+        # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+
+        ax_pthread_flags="-kthread lthread $ax_pthread_flags"
+        ;;
+
+        hpux*)
+
+        # From the cc(1) man page: "[-mt] Sets various -D flags to enable
+        # multi-threading and also sets -lpthread."
+
+        ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"
+        ;;
+
+        openedition*)
+
+        # IBM z/OS requires a feature-test macro to be defined in order to
+        # enable POSIX threads at all, so give the user a hint if this is
+        # not set. (We don't define these ourselves, as they can affect
+        # other portions of the system API in unpredictable ways.)
+
+        AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING],
+            [
+#            if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)
+             AX_PTHREAD_ZOS_MISSING
+#            endif
+            ],
+            [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])])
+        ;;
+
+        solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed. (N.B.: The stubs are missing
+        # pthread_cleanup_push, or rather a function called by this macro,
+        # so we could check for that, but who knows whether they'll stub
+        # that too in a future libc.)  So we'll check first for the
+        # standard Solaris way of linking pthreads (-mt -lpthread).
+
+        ax_pthread_flags="-mt,pthread pthread $ax_pthread_flags"
+        ;;
+esac
+
+# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
+
+AS_IF([test "x$GCC" = "xyes"],
+      [ax_pthread_flags="-pthread -pthreads $ax_pthread_flags"])
+
+# The presence of a feature test macro requesting re-entrant function
+# definitions is, on some systems, a strong hint that pthreads support is
+# correctly enabled
+
+case $host_os in
+        darwin* | hpux* | linux* | osf* | solaris*)
+        ax_pthread_check_macro="_REENTRANT"
+        ;;
+
+        aix*)
+        ax_pthread_check_macro="_THREAD_SAFE"
+        ;;
+
+        *)
+        ax_pthread_check_macro="--"
+        ;;
+esac
+AS_IF([test "x$ax_pthread_check_macro" = "x--"],
+      [ax_pthread_check_cond=0],
+      [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"])
+
+# Are we compiling with Clang?
+
+AC_CACHE_CHECK([whether $CC is Clang],
+    [ax_cv_PTHREAD_CLANG],
+    [ax_cv_PTHREAD_CLANG=no
+     # Note that Autoconf sets GCC=yes for Clang as well as GCC
+     if test "x$GCC" = "xyes"; then
+        AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG],
+            [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */
+#            if defined(__clang__) && defined(__llvm__)
+             AX_PTHREAD_CC_IS_CLANG
+#            endif
+            ],
+            [ax_cv_PTHREAD_CLANG=yes])
+     fi
+    ])
+ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
+
+ax_pthread_clang_warning=no
+
+# Clang needs special handling, because older versions handle the -pthread
+# option in a rather... idiosyncratic way
+
+if test "x$ax_pthread_clang" = "xyes"; then
+
+        # Clang takes -pthread; it has never supported any other flag
+
+        # (Note 1: This will need to be revisited if a system that Clang
+        # supports has POSIX threads in a separate library.  This tends not
+        # to be the way of modern systems, but it's conceivable.)
+
+        # (Note 2: On some systems, notably Darwin, -pthread is not needed
+        # to get POSIX threads support; the API is always present and
+        # active.  We could reasonably leave PTHREAD_CFLAGS empty.  But
+        # -pthread does define _REENTRANT, and while the Darwin headers
+        # ignore this macro, third-party headers might not.)
+
+        PTHREAD_CFLAGS="-pthread"
+        PTHREAD_LIBS=
+
+        ax_pthread_ok=yes
+
+        # However, older versions of Clang make a point of warning the user
+        # that, in an invocation where only linking and no compilation is
+        # taking place, the -pthread option has no effect ("argument unused
+        # during compilation").  They expect -pthread to be passed in only
+        # when source code is being compiled.
+        #
+        # Problem is, this is at odds with the way Automake and most other
+        # C build frameworks function, which is that the same flags used in
+        # compilation (CFLAGS) are also used in linking.  Many systems
+        # supported by AX_PTHREAD require exactly this for POSIX threads
+        # support, and in fact it is often not straightforward to specify a
+        # flag that is used only in the compilation phase and not in
+        # linking.  Such a scenario is extremely rare in practice.
+        #
+        # Even though use of the -pthread flag in linking would only print
+        # a warning, this can be a nuisance for well-run software projects
+        # that build with -Werror.  So if the active version of Clang has
+        # this misfeature, we search for an option to squash it.
+
+        AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown
+             # Create an alternate version of $ac_link that compiles and
+             # links in two steps (.c -> .o, .o -> exe) instead of one
+             # (.c -> exe), because the warning occurs only in the second
+             # step
+             ax_pthread_save_ac_link="$ac_link"
+             ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
+             ax_pthread_link_step=`$as_echo "$ac_link" | sed "$ax_pthread_sed"`
+             ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
+             ax_pthread_save_CFLAGS="$CFLAGS"
+             for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
+                AS_IF([test "x$ax_pthread_try" = "xunknown"], [break])
+                CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"
+                ac_link="$ax_pthread_save_ac_link"
+                AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                    [ac_link="$ax_pthread_2step_ac_link"
+                     AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                         [break])
+                    ])
+             done
+             ac_link="$ax_pthread_save_ac_link"
+             CFLAGS="$ax_pthread_save_CFLAGS"
+             AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no])
+             ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"
+            ])
+
+        case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
+                no | unknown) ;;
+                *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;
+        esac
+
+fi # $ax_pthread_clang = yes
+
+if test "x$ax_pthread_ok" = "xno"; then
+for ax_pthread_try_flag in $ax_pthread_flags; do
+
+        case $ax_pthread_try_flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -mt,pthread)
+                AC_MSG_CHECKING([whether pthreads work with -mt -lpthread])
+                PTHREAD_CFLAGS="-mt"
+                PTHREAD_LIBS="-lpthread"
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag])
+                PTHREAD_CFLAGS="$ax_pthread_try_flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])
+                AS_IF([test "x$ax_pthread_config" = "xno"], [continue])
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag])
+                PTHREAD_LIBS="-l$ax_pthread_try_flag"
+                ;;
+        esac
+
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
+#                       if $ax_pthread_check_cond
+#                        error "$ax_pthread_check_macro must be defined"
+#                       endif
+                        static void routine(void *a) { a = 0; }
+                        static void *start_routine(void *a) { return a; }],
+                       [pthread_t th; pthread_attr_t attr;
+                        pthread_create(&th, 0, start_routine, 0);
+                        pthread_join(th, 0);
+                        pthread_attr_init(&attr);
+                        pthread_cleanup_push(routine, 0);
+                        pthread_cleanup_pop(0) /* ; */])],
+            [ax_pthread_ok=yes],
+            [])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        AC_MSG_RESULT([$ax_pthread_ok])
+        AS_IF([test "x$ax_pthread_ok" = "xyes"], [break])
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_CACHE_CHECK([for joinable pthread attribute],
+            [ax_cv_PTHREAD_JOINABLE_ATTR],
+            [ax_cv_PTHREAD_JOINABLE_ATTR=unknown
+             for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+                 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                                                 [int attr = $ax_pthread_attr; return attr /* ; */])],
+                                [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break],
+                                [])
+             done
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
+               test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
+               test "x$ax_pthread_joinable_attr_defined" != "xyes"],
+              [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE],
+                                  [$ax_cv_PTHREAD_JOINABLE_ATTR],
+                                  [Define to necessary symbol if this constant
+                                   uses a non-standard name on your system.])
+               ax_pthread_joinable_attr_defined=yes
+              ])
+
+        AC_CACHE_CHECK([whether more special flags are required for pthreads],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS=no
+             case $host_os in
+             solaris*)
+             ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"
+             ;;
+             esac
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
+               test "x$ax_pthread_special_flags_added" != "xyes"],
+              [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"
+               ax_pthread_special_flags_added=yes])
+
+        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
+            [ax_cv_PTHREAD_PRIO_INHERIT],
+            [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],
+                                             [[int i = PTHREAD_PRIO_INHERIT;]])],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
+               test "x$ax_pthread_prio_inherit_defined" != "xyes"],
+              [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])
+               ax_pthread_prio_inherit_defined=yes
+              ])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        # More AIX lossage: compile with *_r variant
+        if test "x$GCC" != "xyes"; then
+            case $host_os in
+                aix*)
+                AS_CASE(["x/$CC"],
+                    [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
+                    [#handle absolute path differently from PATH based program lookup
+                     AS_CASE(["x$CC"],
+                         [x/*],
+                         [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])],
+                         [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+
+AC_SUBST([PTHREAD_LIBS])
+AC_SUBST([PTHREAD_CFLAGS])
+AC_SUBST([PTHREAD_CC])
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
+        :
+else
+        ax_pthread_ok=no
+        $2
+fi
+AC_LANG_POP
+])dnl AX_PTHREAD

deps/uv/m4/libuv-check-flags.m4

@@ -0,0 +1,336 @@
+dnl Macros to check the presence of generic (non-typed) symbols.
+dnl Copyright (c) 2006-2008 Diego Pettenò <flameeyes gmail com>
+dnl Copyright (c) 2006-2008 xine project
+dnl Copyright (c) 2021 libuv project
+dnl
+dnl This program is free software; you can redistribute it and/or modify
+dnl it under the terms of the GNU General Public License as published by
+dnl the Free Software Foundation; either version 3, or (at your option)
+dnl any later version.
+dnl
+dnl This program is distributed in the hope that it will be useful,
+dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
+dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+dnl GNU General Public License for more details.
+dnl
+dnl You should have received a copy of the GNU General Public License
+dnl along with this program; if not, write to the Free Software
+dnl Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+dnl 02110-1301, USA.
+dnl
+dnl As a special exception, the copyright owners of the
+dnl macro gives unlimited permission to copy, distribute and modify the
+dnl configure scripts that are the output of Autoconf when processing the
+dnl Macro. You need not follow the terms of the GNU General Public
+dnl License when using or distributing such scripts, even though portions
+dnl of the text of the Macro appear in them. The GNU General Public
+dnl License (GPL) does govern all other use of the material that
+dnl constitutes the Autoconf Macro.
+dnl
+dnl This special exception to the GPL applies to versions of the
+dnl Autoconf Macro released by this project. When you make and
+dnl distribute a modified version of the Autoconf Macro, you may extend
+dnl this special exception to the GPL to apply to your modified version as
+dnl well.
+
+dnl Check if the flag is supported by compiler
+dnl CC_CHECK_CFLAGS_SILENT([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
+
+AC_DEFUN([CC_CHECK_CFLAGS_SILENT], [
+  AC_CACHE_VAL(AS_TR_SH([cc_cv_cflags_$1]),
+    [ac_save_CFLAGS="$CFLAGS"
+     CFLAGS="$CFLAGS $1"
+     AC_COMPILE_IFELSE([AC_LANG_SOURCE([int a;])],
+       [eval "AS_TR_SH([cc_cv_cflags_$1])='yes'"],
+       [eval "AS_TR_SH([cc_cv_cflags_$1])='no'"])
+     CFLAGS="$ac_save_CFLAGS"
+    ])
+
+  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
+    [$2], [$3])
+])
+
+dnl Check if the flag is supported by compiler (cacheable)
+dnl CC_CHECK_CFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
+
+AC_DEFUN([CC_CHECK_CFLAGS], [
+  AC_CACHE_CHECK([if $CC supports $1 flag],
+    AS_TR_SH([cc_cv_cflags_$1]),
+    CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here!
+  )
+
+  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
+    [$2], [$3])
+])
+
+dnl CC_CHECK_CFLAG_APPEND(FLAG, [action-if-found], [action-if-not-found])
+dnl Check for CFLAG and appends them to AM_CFLAGS if supported
+AC_DEFUN([CC_CHECK_CFLAG_APPEND], [
+  AC_CACHE_CHECK([if $CC supports $1 flag],
+    AS_TR_SH([cc_cv_cflags_$1]),
+    CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here!
+  )
+
+  AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes],
+    [AM_CFLAGS="$AM_CFLAGS $1"; DEBUG_CFLAGS="$DEBUG_CFLAGS $1"; $2], [$3])
+
+  AC_SUBST([AM_CFLAGS])
+])
+
+dnl CC_CHECK_CFLAGS_APPEND([FLAG1 FLAG2], [action-if-found], [action-if-not])
+AC_DEFUN([CC_CHECK_CFLAGS_APPEND], [
+  for flag in $1; do
+    CC_CHECK_CFLAG_APPEND($flag, [$2], [$3])
+  done
+])
+
+dnl Check if the flag is supported by linker (cacheable)
+dnl CC_CHECK_LDFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND])
+
+AC_DEFUN([CC_CHECK_LDFLAGS], [
+  AC_CACHE_CHECK([if $CC supports $1 flag],
+    AS_TR_SH([cc_cv_ldflags_$1]),
+    [ac_save_LDFLAGS="$LDFLAGS"
+     LDFLAGS="$LDFLAGS $1"
+     AC_LANG_PUSH([C])
+     AC_LINK_IFELSE([AC_LANG_SOURCE([int main() { return 1; }])],
+       [eval "AS_TR_SH([cc_cv_ldflags_$1])='yes'"],
+       [eval "AS_TR_SH([cc_cv_ldflags_$1])="])
+     AC_LANG_POP([C])
+     LDFLAGS="$ac_save_LDFLAGS"
+    ])
+
+  AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes],
+    [$2], [$3])
+])
+
+dnl Check if flag is supported by both compiler and linker
+dnl If so, append it to AM_CFLAGS
+dnl CC_CHECK_FLAG_SUPPORTED_APPEND([FLAG])
+
+AC_DEFUN([CC_CHECK_FLAG_SUPPORTED_APPEND], [
+  CC_CHECK_CFLAGS([$1],
+    [CC_CHECK_LDFLAGS([$1],
+        [AM_CFLAGS="$AM_CFLAGS $1";
+         DEBUG_CFLAGS="$DEBUG_CFLAGS $1";
+         AC_SUBST([AM_CFLAGS])
+    ])
+  ])
+])
+
+dnl define the LDFLAGS_NOUNDEFINED variable with the correct value for
+dnl the current linker to avoid undefined references in a shared object.
+AC_DEFUN([CC_NOUNDEFINED], [
+  dnl We check $host for which systems to enable this for.
+  AC_REQUIRE([AC_CANONICAL_HOST])
+
+  case $host in
+     dnl FreeBSD (et al.) does not complete linking for shared objects when pthreads
+     dnl are requested, as different implementations are present; to avoid problems
+     dnl use -Wl,-z,defs only for those platform not behaving this way.
+     *-freebsd* | *-openbsd*) ;;
+     *)
+        dnl First of all check for the --no-undefined variant of GNU ld. This allows
+        dnl for a much more readable commandline, so that people can understand what
+        dnl it does without going to look for what the heck -z defs does.
+        for possible_flags in "-Wl,--no-undefined" "-Wl,-z,defs"; do
+          CC_CHECK_LDFLAGS([$possible_flags], [LDFLAGS_NOUNDEFINED="$possible_flags"])
+	  break
+        done
+	;;
+  esac
+
+  AC_SUBST([LDFLAGS_NOUNDEFINED])
+])
+
+dnl Check for a -Werror flag or equivalent. -Werror is the GCC
+dnl and ICC flag that tells the compiler to treat all the warnings
+dnl as fatal. We usually need this option to make sure that some
+dnl constructs (like attributes) are not simply ignored.
+dnl
+dnl Other compilers don't support -Werror per se, but they support
+dnl an equivalent flag:
+dnl  - Sun Studio compiler supports -errwarn=%all
+AC_DEFUN([CC_CHECK_WERROR], [
+  AC_CACHE_CHECK(
+    [for $CC way to treat warnings as errors],
+    [cc_cv_werror],
+    [CC_CHECK_CFLAGS_SILENT([-Werror], [cc_cv_werror=-Werror],
+      [CC_CHECK_CFLAGS_SILENT([-errwarn=%all], [cc_cv_werror=-errwarn=%all])])
+    ])
+])
+
+AC_DEFUN([CC_CHECK_ATTRIBUTE], [
+  AC_REQUIRE([CC_CHECK_WERROR])
+  AC_CACHE_CHECK([if $CC supports __attribute__(( ifelse([$2], , [$1], [$2]) ))],
+    AS_TR_SH([cc_cv_attribute_$1]),
+    [ac_save_CFLAGS="$CFLAGS"
+     CFLAGS="$CFLAGS $cc_cv_werror"
+     AC_LANG_PUSH([C])
+     AC_COMPILE_IFELSE([AC_LANG_SOURCE([$3])],
+       [eval "AS_TR_SH([cc_cv_attribute_$1])='yes'"],
+       [eval "AS_TR_SH([cc_cv_attribute_$1])='no'"])
+     AC_LANG_POP([C])
+     CFLAGS="$ac_save_CFLAGS"
+    ])
+
+  AS_IF([eval test x$]AS_TR_SH([cc_cv_attribute_$1])[ = xyes],
+    [AC_DEFINE(
+       AS_TR_CPP([SUPPORT_ATTRIBUTE_$1]), 1,
+         [Define this if the compiler supports __attribute__(( ifelse([$2], , [$1], [$2]) ))]
+         )
+     $4],
+    [$5])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
+  CC_CHECK_ATTRIBUTE(
+    [constructor],,
+    [void __attribute__((constructor)) ctor() { int a; }],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
+  CC_CHECK_ATTRIBUTE(
+    [format], [format(printf, n, n)],
+    [void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { fmt = (void *)0; }],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_FORMAT_ARG], [
+  CC_CHECK_ATTRIBUTE(
+    [format_arg], [format_arg(printf)],
+    [char *__attribute__((format_arg(1))) gettextlike(const char *fmt) { fmt = (void *)0; }],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
+  CC_CHECK_ATTRIBUTE(
+    [visibility_$1], [visibility("$1")],
+    [void __attribute__((visibility("$1"))) $1_function() { }],
+    [$2], [$3])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
+  CC_CHECK_ATTRIBUTE(
+    [nonnull], [nonnull()],
+    [void __attribute__((nonnull())) some_function(void *foo, void *bar) { foo = (void*)0; bar = (void*)0; }],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
+  CC_CHECK_ATTRIBUTE(
+    [unused], ,
+    [void some_function(void *foo, __attribute__((unused)) void *bar);],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [
+  CC_CHECK_ATTRIBUTE(
+    [sentinel], ,
+    [void some_function(void *foo, ...) __attribute__((sentinel));],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [
+  CC_CHECK_ATTRIBUTE(
+    [deprecated], ,
+    [void some_function(void *foo, ...) __attribute__((deprecated));],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_ALIAS], [
+  CC_CHECK_ATTRIBUTE(
+    [alias], [weak, alias],
+    [void other_function(void *foo) { }
+     void some_function(void *foo) __attribute__((weak, alias("other_function")));],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_MALLOC], [
+  CC_CHECK_ATTRIBUTE(
+    [malloc], ,
+    [void * __attribute__((malloc)) my_alloc(int n);],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_PACKED], [
+  CC_CHECK_ATTRIBUTE(
+    [packed], ,
+    [struct astructure { char a; int b; long c; void *d; } __attribute__((packed));],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_CONST], [
+  CC_CHECK_ATTRIBUTE(
+    [const], ,
+    [int __attribute__((const)) twopow(int n) { return 1 << n; } ],
+    [$1], [$2])
+])
+
+AC_DEFUN([CC_FLAG_VISIBILITY], [
+  AC_REQUIRE([CC_CHECK_WERROR])
+  AC_CACHE_CHECK([if $CC supports -fvisibility=hidden],
+    [cc_cv_flag_visibility],
+    [cc_flag_visibility_save_CFLAGS="$CFLAGS"
+     CFLAGS="$CFLAGS $cc_cv_werror"
+     CC_CHECK_CFLAGS_SILENT([-fvisibility=hidden],
+	cc_cv_flag_visibility='yes',
+	cc_cv_flag_visibility='no')
+     CFLAGS="$cc_flag_visibility_save_CFLAGS"])
+
+  AS_IF([test "x$cc_cv_flag_visibility" = "xyes"],
+    [AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1,
+       [Define this if the compiler supports the -fvisibility flag])
+     $1],
+    [$2])
+])
+
+AC_DEFUN([CC_FUNC_EXPECT], [
+  AC_REQUIRE([CC_CHECK_WERROR])
+  AC_CACHE_CHECK([if compiler has __builtin_expect function],
+    [cc_cv_func_expect],
+    [ac_save_CFLAGS="$CFLAGS"
+     CFLAGS="$CFLAGS $cc_cv_werror"
+     AC_LANG_PUSH([C])
+     AC_COMPILE_IFELSE([AC_LANG_SOURCE(
+       [int some_function() {
+        int a = 3;
+        return (int)__builtin_expect(a, 3);
+	}])],
+       [cc_cv_func_expect=yes],
+       [cc_cv_func_expect=no])
+     AC_LANG_POP([C])
+     CFLAGS="$ac_save_CFLAGS"
+    ])
+
+  AS_IF([test "x$cc_cv_func_expect" = "xyes"],
+    [AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1,
+     [Define this if the compiler supports __builtin_expect() function])
+     $1],
+    [$2])
+])
+
+AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [
+  AC_REQUIRE([CC_CHECK_WERROR])
+  AC_CACHE_CHECK([highest __attribute__ ((aligned ())) supported],
+    [cc_cv_attribute_aligned],
+    [ac_save_CFLAGS="$CFLAGS"
+     CFLAGS="$CFLAGS $cc_cv_werror"
+     AC_LANG_PUSH([C])
+     for cc_attribute_align_try in 64 32 16 8 4 2; do
+        AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+          int main() {
+            static char c __attribute__ ((aligned($cc_attribute_align_try))) = 0;
+            return c;
+          }])], [cc_cv_attribute_aligned=$cc_attribute_align_try; break])
+     done
+     AC_LANG_POP([C])
+     CFLAGS="$ac_save_CFLAGS"
+  ])
+
+  if test "x$cc_cv_attribute_aligned" != "x"; then
+     AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX], [$cc_cv_attribute_aligned],
+       [Define the highest alignment supported])
+  fi
+])

deps/uv/src/fs-poll.c

@@ -0,0 +1,290 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "uv.h"
+#include "uv-common.h"
+
+#ifdef _WIN32
+#include "win/internal.h"
+#include "win/handle-inl.h"
+#define uv__make_close_pending(h) uv__want_endgame((h)->loop, (h))
+#else
+#include "unix/internal.h"
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct poll_ctx {
+  uv_fs_poll_t* parent_handle;
+  int busy_polling;
+  unsigned int interval;
+  uint64_t start_time;
+  uv_loop_t* loop;
+  uv_fs_poll_cb poll_cb;
+  uv_timer_t timer_handle;
+  uv_fs_t fs_req; /* TODO(bnoordhuis) mark fs_req internal */
+  uv_stat_t statbuf;
+  struct poll_ctx* previous; /* context from previous start()..stop() period */
+  char path[1]; /* variable length */
+};
+
+static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b);
+static void poll_cb(uv_fs_t* req);
+static void timer_cb(uv_timer_t* timer);
+static void timer_close_cb(uv_handle_t* timer);
+
+static uv_stat_t zero_statbuf;
+
+
+int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle) {
+  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
+  handle->poll_ctx = NULL;
+  return 0;
+}
+
+
+int uv_fs_poll_start(uv_fs_poll_t* handle,
+                     uv_fs_poll_cb cb,
+                     const char* path,
+                     unsigned int interval) {
+  struct poll_ctx* ctx;
+  uv_loop_t* loop;
+  size_t len;
+  int err;
+
+  if (uv_is_active((uv_handle_t*)handle))
+    return 0;
+
+  loop = handle->loop;
+  len = strlen(path);
+  ctx = uv__calloc(1, sizeof(*ctx) + len);
+
+  if (ctx == NULL)
+    return UV_ENOMEM;
+
+  ctx->loop = loop;
+  ctx->poll_cb = cb;
+  ctx->interval = interval ? interval : 1;
+  ctx->start_time = uv_now(loop);
+  ctx->parent_handle = handle;
+  memcpy(ctx->path, path, len + 1);
+
+  err = uv_timer_init(loop, &ctx->timer_handle);
+  if (err < 0)
+    goto error;
+
+  ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
+  uv__handle_unref(&ctx->timer_handle);
+
+  err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
+  if (err < 0)
+    goto error;
+
+  if (handle->poll_ctx != NULL)
+    ctx->previous = handle->poll_ctx;
+  handle->poll_ctx = ctx;
+  uv__handle_start(handle);
+
+  return 0;
+
+error:
+  uv__free(ctx);
+  return err;
+}
+
+
+int uv_fs_poll_stop(uv_fs_poll_t* handle) {
+  struct poll_ctx* ctx;
+
+  if (!uv_is_active((uv_handle_t*)handle))
+    return 0;
+
+  ctx = handle->poll_ctx;
+  assert(ctx != NULL);
+  assert(ctx->parent_handle == handle);
+
+  /* Close the timer if it's active. If it's inactive, there's a stat request
+   * in progress and poll_cb will take care of the cleanup.
+   */
+  if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
+    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
+
+  uv__handle_stop(handle);
+
+  return 0;
+}
+
+
+int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
+  struct poll_ctx* ctx;
+  size_t required_len;
+
+  if (buffer == NULL || size == NULL || *size == 0)
+    return UV_EINVAL;
+
+  if (!uv_is_active((uv_handle_t*)handle)) {
+    *size = 0;
+    return UV_EINVAL;
+  }
+
+  ctx = handle->poll_ctx;
+  assert(ctx != NULL);
+
+  required_len = strlen(ctx->path);
+  if (required_len >= *size) {
+    *size = required_len + 1;
+    return UV_ENOBUFS;
+  }
+
+  memcpy(buffer, ctx->path, required_len);
+  *size = required_len;
+  buffer[required_len] = '\0';
+
+  return 0;
+}
+
+
+void uv__fs_poll_close(uv_fs_poll_t* handle) {
+  uv_fs_poll_stop(handle);
+
+  if (handle->poll_ctx == NULL)
+    uv__make_close_pending((uv_handle_t*)handle);
+}
+
+
+static void timer_cb(uv_timer_t* timer) {
+  struct poll_ctx* ctx;
+
+  ctx = container_of(timer, struct poll_ctx, timer_handle);
+  assert(ctx->parent_handle != NULL);
+  assert(ctx->parent_handle->poll_ctx == ctx);
+  ctx->start_time = uv_now(ctx->loop);
+
+  if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
+    abort();
+}
+
+
+static void poll_cb(uv_fs_t* req) {
+  uv_stat_t* statbuf;
+  struct poll_ctx* ctx;
+  uint64_t interval;
+  uv_fs_poll_t* handle;
+
+  ctx = container_of(req, struct poll_ctx, fs_req);
+  handle = ctx->parent_handle;
+
+  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
+    goto out;
+
+  if (req->result != 0) {
+    if (ctx->busy_polling != req->result) {
+      ctx->poll_cb(ctx->parent_handle,
+                   req->result,
+                   &ctx->statbuf,
+                   &zero_statbuf);
+      ctx->busy_polling = req->result;
+    }
+    goto out;
+  }
+
+  statbuf = &req->statbuf;
+
+  if (ctx->busy_polling != 0)
+    if (ctx->busy_polling < 0 || !statbuf_eq(&ctx->statbuf, statbuf))
+      ctx->poll_cb(ctx->parent_handle, 0, &ctx->statbuf, statbuf);
+
+  ctx->statbuf = *statbuf;
+  ctx->busy_polling = 1;
+
+out:
+  uv_fs_req_cleanup(req);
+
+  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {
+    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
+    return;
+  }
+
+  /* Reschedule timer, subtract the delay from doing the stat(). */
+  interval = ctx->interval;
+  interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;
+
+  if (uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0))
+    abort();
+}
+
+
+static void timer_close_cb(uv_handle_t* timer) {
+  struct poll_ctx* ctx;
+  struct poll_ctx* it;
+  struct poll_ctx* last;
+  uv_fs_poll_t* handle;
+
+  ctx = container_of(timer, struct poll_ctx, timer_handle);
+  handle = ctx->parent_handle;
+  if (ctx == handle->poll_ctx) {
+    handle->poll_ctx = ctx->previous;
+    if (handle->poll_ctx == NULL && uv__is_closing(handle))
+      uv__make_close_pending((uv_handle_t*)handle);
+  } else {
+    for (last = handle->poll_ctx, it = last->previous;
+         it != ctx;
+         last = it, it = it->previous) {
+      assert(last->previous != NULL);
+    }
+    last->previous = ctx->previous;
+  }
+  uv__free(ctx);
+}
+
+
+static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
+  return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec
+      && a->st_mtim.tv_nsec == b->st_mtim.tv_nsec
+      && a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec
+      && a->st_ctim.tv_sec == b->st_ctim.tv_sec
+      && a->st_mtim.tv_sec == b->st_mtim.tv_sec
+      && a->st_birthtim.tv_sec == b->st_birthtim.tv_sec
+      && a->st_size == b->st_size
+      && a->st_mode == b->st_mode
+      && a->st_uid == b->st_uid
+      && a->st_gid == b->st_gid
+      && a->st_ino == b->st_ino
+      && a->st_dev == b->st_dev
+      && a->st_flags == b->st_flags
+      && a->st_gen == b->st_gen;
+}
+
+
+#if defined(_WIN32)
+
+#include "win/internal.h"
+#include "win/handle-inl.h"
+
+void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
+  assert(handle->flags & UV_HANDLE_CLOSING);
+  assert(!(handle->flags & UV_HANDLE_CLOSED));
+  uv__handle_close(handle);
+}
+
+#endif /* _WIN32 */

deps/uv/src/heap-inl.h

@@ -0,0 +1,245 @@
+/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef UV_SRC_HEAP_H_
+#define UV_SRC_HEAP_H_
+
+#include <stddef.h>  /* NULL */
+
+#if defined(__GNUC__)
+# define HEAP_EXPORT(declaration) __attribute__((unused)) static declaration
+#else
+# define HEAP_EXPORT(declaration) static declaration
+#endif
+
+struct heap_node {
+  struct heap_node* left;
+  struct heap_node* right;
+  struct heap_node* parent;
+};
+
+/* A binary min heap.  The usual properties hold: the root is the lowest
+ * element in the set, the height of the tree is at most log2(nodes) and
+ * it's always a complete binary tree.
+ *
+ * The heap function try hard to detect corrupted tree nodes at the cost
+ * of a minor reduction in performance.  Compile with -DNDEBUG to disable.
+ */
+struct heap {
+  struct heap_node* min;
+  unsigned int nelts;
+};
+
+/* Return non-zero if a < b. */
+typedef int (*heap_compare_fn)(const struct heap_node* a,
+                               const struct heap_node* b);
+
+/* Public functions. */
+HEAP_EXPORT(void heap_init(struct heap* heap));
+HEAP_EXPORT(struct heap_node* heap_min(const struct heap* heap));
+HEAP_EXPORT(void heap_insert(struct heap* heap,
+                             struct heap_node* newnode,
+                             heap_compare_fn less_than));
+HEAP_EXPORT(void heap_remove(struct heap* heap,
+                             struct heap_node* node,
+                             heap_compare_fn less_than));
+HEAP_EXPORT(void heap_dequeue(struct heap* heap, heap_compare_fn less_than));
+
+/* Implementation follows. */
+
+HEAP_EXPORT(void heap_init(struct heap* heap)) {
+  heap->min = NULL;
+  heap->nelts = 0;
+}
+
+HEAP_EXPORT(struct heap_node* heap_min(const struct heap* heap)) {
+  return heap->min;
+}
+
+/* Swap parent with child. Child moves closer to the root, parent moves away. */
+static void heap_node_swap(struct heap* heap,
+                           struct heap_node* parent,
+                           struct heap_node* child) {
+  struct heap_node* sibling;
+  struct heap_node t;
+
+  t = *parent;
+  *parent = *child;
+  *child = t;
+
+  parent->parent = child;
+  if (child->left == child) {
+    child->left = parent;
+    sibling = child->right;
+  } else {
+    child->right = parent;
+    sibling = child->left;
+  }
+  if (sibling != NULL)
+    sibling->parent = child;
+
+  if (parent->left != NULL)
+    parent->left->parent = parent;
+  if (parent->right != NULL)
+    parent->right->parent = parent;
+
+  if (child->parent == NULL)
+    heap->min = child;
+  else if (child->parent->left == parent)
+    child->parent->left = child;
+  else
+    child->parent->right = child;
+}
+
+HEAP_EXPORT(void heap_insert(struct heap* heap,
+                             struct heap_node* newnode,
+                             heap_compare_fn less_than)) {
+  struct heap_node** parent;
+  struct heap_node** child;
+  unsigned int path;
+  unsigned int n;
+  unsigned int k;
+
+  newnode->left = NULL;
+  newnode->right = NULL;
+  newnode->parent = NULL;
+
+  /* Calculate the path from the root to the insertion point.  This is a min
+   * heap so we always insert at the left-most free node of the bottom row.
+   */
+  path = 0;
+  for (k = 0, n = 1 + heap->nelts; n >= 2; k += 1, n /= 2)
+    path = (path << 1) | (n & 1);
+
+  /* Now traverse the heap using the path we calculated in the previous step. */
+  parent = child = &heap->min;
+  while (k > 0) {
+    parent = child;
+    if (path & 1)
+      child = &(*child)->right;
+    else
+      child = &(*child)->left;
+    path >>= 1;
+    k -= 1;
+  }
+
+  /* Insert the new node. */
+  newnode->parent = *parent;
+  *child = newnode;
+  heap->nelts += 1;
+
+  /* Walk up the tree and check at each node if the heap property holds.
+   * It's a min heap so parent < child must be true.
+   */
+  while (newnode->parent != NULL && less_than(newnode, newnode->parent))
+    heap_node_swap(heap, newnode->parent, newnode);
+}
+
+HEAP_EXPORT(void heap_remove(struct heap* heap,
+                             struct heap_node* node,
+                             heap_compare_fn less_than)) {
+  struct heap_node* smallest;
+  struct heap_node** max;
+  struct heap_node* child;
+  unsigned int path;
+  unsigned int k;
+  unsigned int n;
+
+  if (heap->nelts == 0)
+    return;
+
+  /* Calculate the path from the min (the root) to the max, the left-most node
+   * of the bottom row.
+   */
+  path = 0;
+  for (k = 0, n = heap->nelts; n >= 2; k += 1, n /= 2)
+    path = (path << 1) | (n & 1);
+
+  /* Now traverse the heap using the path we calculated in the previous step. */
+  max = &heap->min;
+  while (k > 0) {
+    if (path & 1)
+      max = &(*max)->right;
+    else
+      max = &(*max)->left;
+    path >>= 1;
+    k -= 1;
+  }
+
+  heap->nelts -= 1;
+
+  /* Unlink the max node. */
+  child = *max;
+  *max = NULL;
+
+  if (child == node) {
+    /* We're removing either the max or the last node in the tree. */
+    if (child == heap->min) {
+      heap->min = NULL;
+    }
+    return;
+  }
+
+  /* Replace the to be deleted node with the max node. */
+  child->left = node->left;
+  child->right = node->right;
+  child->parent = node->parent;
+
+  if (child->left != NULL) {
+    child->left->parent = child;
+  }
+
+  if (child->right != NULL) {
+    child->right->parent = child;
+  }
+
+  if (node->parent == NULL) {
+    heap->min = child;
+  } else if (node->parent->left == node) {
+    node->parent->left = child;
+  } else {
+    node->parent->right = child;
+  }
+
+  /* Walk down the subtree and check at each node if the heap property holds.
+   * It's a min heap so parent < child must be true.  If the parent is bigger,
+   * swap it with the smallest child.
+   */
+  for (;;) {
+    smallest = child;
+    if (child->left != NULL && less_than(child->left, smallest))
+      smallest = child->left;
+    if (child->right != NULL && less_than(child->right, smallest))
+      smallest = child->right;
+    if (smallest == child)
+      break;
+    heap_node_swap(heap, child, smallest);
+  }
+
+  /* Walk up the subtree and check that each parent is less than the node
+   * this is required, because `max` node is not guaranteed to be the
+   * actual maximum in tree
+   */
+  while (child->parent != NULL && less_than(child, child->parent))
+    heap_node_swap(heap, child->parent, child);
+}
+
+HEAP_EXPORT(void heap_dequeue(struct heap* heap, heap_compare_fn less_than)) {
+  heap_remove(heap, heap->min, less_than);
+}
+
+#undef HEAP_EXPORT
+
+#endif  /* UV_SRC_HEAP_H_ */

deps/uv/src/idna.c

@@ -0,0 +1,560 @@
+/* Copyright libuv contributors. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/* Derived from https://github.com/bnoordhuis/punycode
+ * but updated to support IDNA 2008.
+ */
+
+#include "uv.h"
+#include "uv-common.h"
+#include "idna.h"
+#include <assert.h>
+#include <string.h>
+#include <limits.h> /* UINT_MAX */
+
+
+static int32_t uv__wtf8_decode1(const char** input) {
+  uint32_t code_point;
+  uint8_t b1;
+  uint8_t b2;
+  uint8_t b3;
+  uint8_t b4;
+
+  b1 = **input;
+  if (b1 <= 0x7F)
+    return b1; /* ASCII code point */
+  if (b1 < 0xC2)
+    return -1; /* invalid: continuation byte */
+  code_point = b1;
+
+  b2 = *++*input;
+  if ((b2 & 0xC0) != 0x80)
+    return -1; /* invalid: not a continuation byte */
+  code_point = (code_point << 6) | (b2 & 0x3F);
+  if (b1 <= 0xDF)
+    return 0x7FF & code_point; /* two-byte character */
+
+  b3 = *++*input;
+  if ((b3 & 0xC0) != 0x80)
+    return -1; /* invalid: not a continuation byte */
+  code_point = (code_point << 6) | (b3 & 0x3F);
+  if (b1 <= 0xEF)
+    return 0xFFFF & code_point; /* three-byte character */
+
+  b4 = *++*input;
+  if ((b4 & 0xC0) != 0x80)
+    return -1; /* invalid: not a continuation byte */
+  code_point = (code_point << 6) | (b4 & 0x3F);
+  if (b1 <= 0xF4) {
+    code_point &= 0x1FFFFF;
+    if (code_point <= 0x10FFFF)
+      return code_point; /* four-byte character */
+  }
+
+  /* code point too large */
+  return -1;
+}
+
+
+static unsigned uv__utf8_decode1_slow(const char** p,
+                                      const char* pe,
+                                      unsigned a) {
+  unsigned b;
+  unsigned c;
+  unsigned d;
+  unsigned min;
+
+  if (a > 0xF7)
+    return -1;
+
+  switch (pe - *p) {
+  default:
+    if (a > 0xEF) {
+      min = 0x10000;
+      a = a & 7;
+      b = (unsigned char) *(*p)++;
+      c = (unsigned char) *(*p)++;
+      d = (unsigned char) *(*p)++;
+      break;
+    }
+    /* Fall through. */
+  case 2:
+    if (a > 0xDF) {
+      min = 0x800;
+      b = 0x80 | (a & 15);
+      c = (unsigned char) *(*p)++;
+      d = (unsigned char) *(*p)++;
+      a = 0;
+      break;
+    }
+    /* Fall through. */
+  case 1:
+    if (a > 0xBF) {
+      min = 0x80;
+      b = 0x80;
+      c = 0x80 | (a & 31);
+      d = (unsigned char) *(*p)++;
+      a = 0;
+      break;
+    }
+    /* Fall through. */
+  case 0:
+    return -1;  /* Invalid continuation byte. */
+  }
+
+  if (0x80 != (0xC0 & (b ^ c ^ d)))
+    return -1;  /* Invalid sequence. */
+
+  b &= 63;
+  c &= 63;
+  d &= 63;
+  a = (a << 18) | (b << 12) | (c << 6) | d;
+
+  if (a < min)
+    return -1;  /* Overlong sequence. */
+
+  if (a > 0x10FFFF)
+    return -1;  /* Four-byte sequence > U+10FFFF. */
+
+  if (a >= 0xD800 && a <= 0xDFFF)
+    return -1;  /* Surrogate pair. */
+
+  return a;
+}
+
+
+unsigned uv__utf8_decode1(const char** p, const char* pe) {
+  unsigned a;
+
+  assert(*p < pe);
+
+  a = (unsigned char) *(*p)++;
+
+  if (a < 128)
+    return a;  /* ASCII, common case. */
+
+  return uv__utf8_decode1_slow(p, pe, a);
+}
+
+
+static int uv__idna_toascii_label(const char* s, const char* se,
+                                  char** d, char* de) {
+  static const char alphabet[] = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const char* ss;
+  unsigned c;
+  unsigned h;
+  unsigned k;
+  unsigned n;
+  unsigned m;
+  unsigned q;
+  unsigned t;
+  unsigned x;
+  unsigned y;
+  unsigned bias;
+  unsigned delta;
+  unsigned todo;
+  int first;
+
+  h = 0;
+  ss = s;
+  todo = 0;
+
+  /* Note: after this loop we've visited all UTF-8 characters and know
+   * they're legal so we no longer need to check for decode errors.
+   */
+  while (s < se) {
+    c = uv__utf8_decode1(&s, se);
+
+    if (c == UINT_MAX)
+      return UV_EINVAL;
+
+    if (c < 128)
+      h++;
+    else
+      todo++;
+  }
+
+  /* Only write "xn--" when there are non-ASCII characters. */
+  if (todo > 0) {
+    if (*d < de) *(*d)++ = 'x';
+    if (*d < de) *(*d)++ = 'n';
+    if (*d < de) *(*d)++ = '-';
+    if (*d < de) *(*d)++ = '-';
+  }
+
+  /* Write ASCII characters. */
+  x = 0;
+  s = ss;
+  while (s < se) {
+    c = uv__utf8_decode1(&s, se);
+    assert(c != UINT_MAX);
+
+    if (c > 127)
+      continue;
+
+    if (*d < de)
+      *(*d)++ = c;
+
+    if (++x == h)
+      break;  /* Visited all ASCII characters. */
+  }
+
+  if (todo == 0)
+    return h;
+
+  /* Only write separator when we've written ASCII characters first. */
+  if (h > 0)
+    if (*d < de)
+      *(*d)++ = '-';
+
+  n = 128;
+  bias = 72;
+  delta = 0;
+  first = 1;
+
+  while (todo > 0) {
+    m = -1;
+    s = ss;
+
+    while (s < se) {
+      c = uv__utf8_decode1(&s, se);
+      assert(c != UINT_MAX);
+
+      if (c >= n)
+        if (c < m)
+          m = c;
+    }
+
+    x = m - n;
+    y = h + 1;
+
+    if (x > ~delta / y)
+      return UV_E2BIG;  /* Overflow. */
+
+    delta += x * y;
+    n = m;
+
+    s = ss;
+    while (s < se) {
+      c = uv__utf8_decode1(&s, se);
+      assert(c != UINT_MAX);
+
+      if (c < n)
+        if (++delta == 0)
+          return UV_E2BIG;  /* Overflow. */
+
+      if (c != n)
+        continue;
+
+      for (k = 36, q = delta; /* empty */; k += 36) {
+        t = 1;
+
+        if (k > bias)
+          t = k - bias;
+
+        if (t > 26)
+          t = 26;
+
+        if (q < t)
+          break;
+
+        /* TODO(bnoordhuis) Since 1 <= t <= 26 and therefore
+         * 10 <= y <= 35, we can optimize the long division
+         * into a table-based reciprocal multiplication.
+         */
+        x = q - t;
+        y = 36 - t;  /* 10 <= y <= 35 since 1 <= t <= 26. */
+        q = x / y;
+        t = t + x % y;  /* 1 <= t <= 35 because of y. */
+
+        if (*d < de)
+          *(*d)++ = alphabet[t];
+      }
+
+      if (*d < de)
+        *(*d)++ = alphabet[q];
+
+      delta /= 2;
+
+      if (first) {
+        delta /= 350;
+        first = 0;
+      }
+
+      /* No overflow check is needed because |delta| was just
+       * divided by 2 and |delta+delta >= delta + delta/h|.
+       */
+      h++;
+      delta += delta / h;
+
+      for (bias = 0; delta > 35 * 26 / 2; bias += 36)
+        delta /= 35;
+
+      bias += 36 * delta / (delta + 38);
+      delta = 0;
+      todo--;
+    }
+
+    delta++;
+    n++;
+  }
+
+  return 0;
+}
+
+
+ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de) {
+  const char* si;
+  const char* st;
+  unsigned c;
+  char* ds;
+  int rc;
+
+  if (s == se)
+    return UV_EINVAL;
+
+  ds = d;
+
+  si = s;
+  while (si < se) {
+    st = si;
+    c = uv__utf8_decode1(&si, se);
+
+    if (c == UINT_MAX)
+      return UV_EINVAL;
+
+    if (c != '.')
+      if (c != 0x3002)  /* 。 */
+        if (c != 0xFF0E)  /* ． */
+          if (c != 0xFF61)  /* ｡ */
+            continue;
+
+    rc = uv__idna_toascii_label(s, st, &d, de);
+
+    if (rc < 0)
+      return rc;
+
+    if (d < de)
+      *d++ = '.';
+
+    s = si;
+  }
+
+  if (s < se) {
+    rc = uv__idna_toascii_label(s, se, &d, de);
+
+    if (rc < 0)
+      return rc;
+  }
+
+  if (d >= de)
+    return UV_EINVAL;
+
+  *d++ = '\0';
+  return d - ds;  /* Number of bytes written. */
+}
+
+
+ssize_t uv_wtf8_length_as_utf16(const char* source_ptr) {
+  size_t w_target_len = 0;
+  int32_t code_point;
+
+  do {
+    code_point = uv__wtf8_decode1(&source_ptr);
+    if (code_point < 0)
+      return -1;
+    if (code_point > 0xFFFF)
+      w_target_len++;
+    w_target_len++;
+  } while (*source_ptr++);
+
+  return w_target_len;
+}
+
+
+void uv_wtf8_to_utf16(const char* source_ptr,
+                      uint16_t* w_target,
+                      size_t w_target_len) {
+  int32_t code_point;
+
+  do {
+    code_point = uv__wtf8_decode1(&source_ptr);
+    /* uv_wtf8_length_as_utf16 should have been called and checked first. */
+    assert(code_point >= 0);
+    if (code_point > 0xFFFF) {
+      assert(code_point < 0x10FFFF);
+      *w_target++ = (((code_point - 0x10000) >> 10) + 0xD800);
+      *w_target++ = ((code_point - 0x10000) & 0x3FF) + 0xDC00;
+      w_target_len -= 2;
+    } else {
+      *w_target++ = code_point;
+      w_target_len -= 1;
+    }
+  } while (*source_ptr++);
+
+  (void)w_target_len;
+  assert(w_target_len == 0);
+}
+
+
+static int32_t uv__get_surrogate_value(const uint16_t* w_source_ptr,
+                                       ssize_t w_source_len) {
+  uint16_t u;
+  uint16_t next;
+
+  u = w_source_ptr[0];
+  if (u >= 0xD800 && u <= 0xDBFF && w_source_len != 1) {
+    next = w_source_ptr[1];
+    if (next >= 0xDC00 && next <= 0xDFFF)
+      return 0x10000 + ((u - 0xD800) << 10) + (next - 0xDC00);
+  }
+  return u;
+}
+
+
+size_t uv_utf16_length_as_wtf8(const uint16_t* w_source_ptr,
+                               ssize_t w_source_len) {
+  size_t target_len;
+  int32_t code_point;
+
+  target_len = 0;
+  while (w_source_len) {
+    code_point = uv__get_surrogate_value(w_source_ptr, w_source_len);
+    /* Can be invalid UTF-8 but must be valid WTF-8. */
+    assert(code_point >= 0);
+    if (w_source_len < 0 && code_point == 0)
+      break;
+    if (code_point < 0x80)
+      target_len += 1;
+    else if (code_point < 0x800)
+      target_len += 2;
+    else if (code_point < 0x10000)
+      target_len += 3;
+    else {
+      target_len += 4;
+      w_source_ptr++;
+      if (w_source_len > 0)
+        w_source_len--;
+    }
+    w_source_ptr++;
+    if (w_source_len > 0)
+      w_source_len--;
+  }
+
+  return target_len;
+}
+
+
+int uv_utf16_to_wtf8(const uint16_t* w_source_ptr,
+                     ssize_t w_source_len,
+                     char** target_ptr,
+                     size_t* target_len_ptr) {
+  size_t target_len;
+  char* target;
+  char* target_end;
+  int32_t code_point;
+
+  /* If *target_ptr is provided, then *target_len_ptr must be its length
+   * (excluding space for NUL), otherwise we will compute the target_len_ptr
+   * length and may return a new allocation in *target_ptr if target_ptr is
+   * provided. */
+  if (target_ptr == NULL || *target_ptr == NULL) {
+    target_len = uv_utf16_length_as_wtf8(w_source_ptr, w_source_len);
+    if (target_len_ptr != NULL)
+      *target_len_ptr = target_len;
+  } else {
+    target_len = *target_len_ptr;
+  }
+
+  if (target_ptr == NULL)
+    return 0;
+
+  if (*target_ptr == NULL) {
+    target = uv__malloc(target_len + 1);
+    if (target == NULL) {
+      return UV_ENOMEM;
+    }
+    *target_ptr = target;
+  } else {
+    target = *target_ptr;
+  }
+
+  target_end = target + target_len;
+
+  while (target != target_end && w_source_len) {
+    code_point = uv__get_surrogate_value(w_source_ptr, w_source_len);
+    /* Can be invalid UTF-8 but must be valid WTF-8. */
+    assert(code_point >= 0);
+    if (w_source_len < 0 && code_point == 0) {
+      w_source_len = 0;
+      break;
+    }
+    if (code_point < 0x80) {
+      *target++ = code_point;
+    } else if (code_point < 0x800) {
+      *target++ = 0xC0 | (code_point >> 6);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | (code_point & 0x3F);
+    } else if (code_point < 0x10000) {
+      *target++ = 0xE0 | (code_point >> 12);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | ((code_point >> 6) & 0x3F);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | (code_point & 0x3F);
+    } else {
+      *target++ = 0xF0 | (code_point >> 18);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | ((code_point >> 12) & 0x3F);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | ((code_point >> 6) & 0x3F);
+      if (target == target_end)
+        break;
+      *target++ = 0x80 | (code_point & 0x3F);
+      /* uv__get_surrogate_value consumed 2 input characters */
+      w_source_ptr++;
+      if (w_source_len > 0)
+        w_source_len--;
+    }
+    target_len = target - *target_ptr;
+    w_source_ptr++;
+    if (w_source_len > 0)
+      w_source_len--;
+  }
+
+  if (target != target_end && target_len_ptr != NULL)
+    /* Did not fill all of the provided buffer, so update the target_len_ptr
+     * output with the space used. */
+    *target_len_ptr = target - *target_ptr;
+
+  /* Check if input fit into target exactly. */
+  if (w_source_len < 0 && target == target_end && w_source_ptr[0] == 0)
+    w_source_len = 0;
+
+  *target++ = '\0';
+
+  /* Characters remained after filling the buffer, compute the remaining length now. */
+  if (w_source_len) {
+    if (target_len_ptr != NULL)
+      *target_len_ptr = target_len + uv_utf16_length_as_wtf8(w_source_ptr, w_source_len);
+    return UV_ENOBUFS;
+  }
+
+  return 0;
+}

deps/uv/src/idna.h

@@ -0,0 +1,31 @@
+/* Copyright libuv contributors. All rights reserved.
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef UV_SRC_IDNA_H_
+#define UV_SRC_IDNA_H_
+
+/* Decode a single codepoint. Returns the codepoint or UINT32_MAX on error.
+ * |p| is updated on success _and_ error, i.e., bad multi-byte sequences are
+ * skipped in their entirety, not just the first bad byte.
+ */
+unsigned uv__utf8_decode1(const char** p, const char* pe);
+
+/* Convert a UTF-8 domain name to IDNA 2008 / Punycode. A return value >= 0
+ * is the number of bytes written to |d|, including the trailing nul byte.
+ * A return value < 0 is a libuv error code. |s| and |d| can not overlap.
+ */
+ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de);
+
+#endif  /* UV_SRC_IDNA_H_ */

deps/uv/src/inet.c

@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 1996-1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "uv.h"
+#include "uv-common.h"
+
+#define UV__INET_ADDRSTRLEN         16
+#define UV__INET6_ADDRSTRLEN        46
+
+
+static int inet_ntop4(const unsigned char *src, char *dst, size_t size);
+static int inet_ntop6(const unsigned char *src, char *dst, size_t size);
+static int inet_pton4(const char *src, unsigned char *dst);
+static int inet_pton6(const char *src, unsigned char *dst);
+
+
+int uv_inet_ntop(int af, const void* src, char* dst, size_t size) {
+  switch (af) {
+  case AF_INET:
+    return (inet_ntop4(src, dst, size));
+  case AF_INET6:
+    return (inet_ntop6(src, dst, size));
+  default:
+    return UV_EAFNOSUPPORT;
+  }
+  /* NOTREACHED */
+}
+
+
+static int inet_ntop4(const unsigned char *src, char *dst, size_t size) {
+  static const char fmt[] = "%u.%u.%u.%u";
+  char tmp[UV__INET_ADDRSTRLEN];
+  int l;
+
+  l = snprintf(tmp, sizeof(tmp), fmt, src[0], src[1], src[2], src[3]);
+  if (l <= 0 || (size_t) l >= size) {
+    return UV_ENOSPC;
+  }
+  uv__strscpy(dst, tmp, size);
+  return 0;
+}
+
+
+static int inet_ntop6(const unsigned char *src, char *dst, size_t size) {
+  /*
+   * Note that int32_t and int16_t need only be "at least" large enough
+   * to contain a value of the specified size.  On some systems, like
+   * Crays, there is no such thing as an integer variable with 16 bits.
+   * Keep this in mind if you think this function should have been coded
+   * to use pointer overlays.  All the world's not a VAX.
+   */
+  char tmp[UV__INET6_ADDRSTRLEN], *tp;
+  struct { int base, len; } best, cur;
+  unsigned int words[sizeof(struct in6_addr) / sizeof(uint16_t)];
+  int i;
+
+  /*
+   * Preprocess:
+   *  Copy the input (bytewise) array into a wordwise array.
+   *  Find the longest run of 0x00's in src[] for :: shorthanding.
+   */
+  memset(words, '\0', sizeof words);
+  for (i = 0; i < (int) sizeof(struct in6_addr); i++)
+    words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+  best.base = -1;
+  best.len = 0;
+  cur.base = -1;
+  cur.len = 0;
+  for (i = 0; i < (int) ARRAY_SIZE(words); i++) {
+    if (words[i] == 0) {
+      if (cur.base == -1)
+        cur.base = i, cur.len = 1;
+      else
+        cur.len++;
+    } else {
+      if (cur.base != -1) {
+        if (best.base == -1 || cur.len > best.len)
+          best = cur;
+        cur.base = -1;
+      }
+    }
+  }
+  if (cur.base != -1) {
+    if (best.base == -1 || cur.len > best.len)
+      best = cur;
+  }
+  if (best.base != -1 && best.len < 2)
+    best.base = -1;
+
+  /*
+   * Format the result.
+   */
+  tp = tmp;
+  for (i = 0; i < (int) ARRAY_SIZE(words); i++) {
+    /* Are we inside the best run of 0x00's? */
+    if (best.base != -1 && i >= best.base &&
+        i < (best.base + best.len)) {
+      if (i == best.base)
+        *tp++ = ':';
+      continue;
+    }
+    /* Are we following an initial run of 0x00s or any real hex? */
+    if (i != 0)
+      *tp++ = ':';
+    /* Is this address an encapsulated IPv4? */
+    if (i == 6 && best.base == 0 && (best.len == 6 ||
+        (best.len == 7 && words[7] != 0x0001) ||
+        (best.len == 5 && words[5] == 0xffff))) {
+      int err = inet_ntop4(src+12, tp, sizeof tmp - (tp - tmp));
+      if (err)
+        return err;
+      tp += strlen(tp);
+      break;
+    }
+    tp += snprintf(tp, sizeof tmp - (tp - tmp), "%x", words[i]);
+  }
+  /* Was it a trailing run of 0x00's? */
+  if (best.base != -1 && (best.base + best.len) == ARRAY_SIZE(words))
+    *tp++ = ':';
+  *tp++ = '\0';
+  if ((size_t) (tp - tmp) > size)
+    return UV_ENOSPC;
+  uv__strscpy(dst, tmp, size);
+  return 0;
+}
+
+
+int uv_inet_pton(int af, const char* src, void* dst) {
+  if (src == NULL || dst == NULL)
+    return UV_EINVAL;
+
+  switch (af) {
+  case AF_INET:
+    return (inet_pton4(src, dst));
+  case AF_INET6: {
+    int len;
+    char tmp[UV__INET6_ADDRSTRLEN], *s, *p;
+    s = (char*) src;
+    p = strchr(src, '%');
+    if (p != NULL) {
+      s = tmp;
+      len = p - src;
+      if (len > UV__INET6_ADDRSTRLEN-1)
+        return UV_EINVAL;
+      memcpy(s, src, len);
+      s[len] = '\0';
+    }
+    return inet_pton6(s, dst);
+  }
+  default:
+    return UV_EAFNOSUPPORT;
+  }
+  /* NOTREACHED */
+}
+
+
+static int inet_pton4(const char *src, unsigned char *dst) {
+  static const char digits[] = "0123456789";
+  int saw_digit, octets, ch;
+  unsigned char tmp[sizeof(struct in_addr)], *tp;
+
+  saw_digit = 0;
+  octets = 0;
+  *(tp = tmp) = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    if ((pch = strchr(digits, ch)) != NULL) {
+      unsigned int nw = *tp * 10 + (pch - digits);
+
+      if (saw_digit && *tp == 0)
+        return UV_EINVAL;
+      if (nw > 255)
+        return UV_EINVAL;
+      *tp = nw;
+      if (!saw_digit) {
+        if (++octets > 4)
+          return UV_EINVAL;
+        saw_digit = 1;
+      }
+    } else if (ch == '.' && saw_digit) {
+      if (octets == 4)
+        return UV_EINVAL;
+      *++tp = 0;
+      saw_digit = 0;
+    } else
+      return UV_EINVAL;
+  }
+  if (octets < 4)
+    return UV_EINVAL;
+  memcpy(dst, tmp, sizeof(struct in_addr));
+  return 0;
+}
+
+
+static int inet_pton6(const char *src, unsigned char *dst) {
+  static const char xdigits_l[] = "0123456789abcdef",
+                    xdigits_u[] = "0123456789ABCDEF";
+  unsigned char tmp[sizeof(struct in6_addr)], *tp, *endp, *colonp;
+  const char *xdigits, *curtok;
+  int ch, seen_xdigits;
+  unsigned int val;
+
+  memset((tp = tmp), '\0', sizeof tmp);
+  endp = tp + sizeof tmp;
+  colonp = NULL;
+  /* Leading :: requires some special handling. */
+  if (*src == ':')
+    if (*++src != ':')
+      return UV_EINVAL;
+  curtok = src;
+  seen_xdigits = 0;
+  val = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+      pch = strchr((xdigits = xdigits_u), ch);
+    if (pch != NULL) {
+      val <<= 4;
+      val |= (pch - xdigits);
+      if (++seen_xdigits > 4)
+        return UV_EINVAL;
+      continue;
+    }
+    if (ch == ':') {
+      curtok = src;
+      if (!seen_xdigits) {
+        if (colonp)
+          return UV_EINVAL;
+        colonp = tp;
+        continue;
+      } else if (*src == '\0') {
+        return UV_EINVAL;
+      }
+      if (tp + sizeof(uint16_t) > endp)
+        return UV_EINVAL;
+      *tp++ = (unsigned char) (val >> 8) & 0xff;
+      *tp++ = (unsigned char) val & 0xff;
+      seen_xdigits = 0;
+      val = 0;
+      continue;
+    }
+    if (ch == '.' && ((tp + sizeof(struct in_addr)) <= endp)) {
+      int err = inet_pton4(curtok, tp);
+      if (err == 0) {
+        tp += sizeof(struct in_addr);
+        seen_xdigits = 0;
+        break;  /*%< '\\0' was seen by inet_pton4(). */
+      }
+    }
+    return UV_EINVAL;
+  }
+  if (seen_xdigits) {
+    if (tp + sizeof(uint16_t) > endp)
+      return UV_EINVAL;
+    *tp++ = (unsigned char) (val >> 8) & 0xff;
+    *tp++ = (unsigned char) val & 0xff;
+  }
+  if (colonp != NULL) {
+    /*
+     * Since some memmove()'s erroneously fail to handle
+     * overlapping regions, we'll do the shift by hand.
+     */
+    const int n = tp - colonp;
+    int i;
+
+    if (tp == endp)
+      return UV_EINVAL;
+    for (i = 1; i <= n; i++) {
+      endp[- i] = colonp[n - i];
+      colonp[n - i] = 0;
+    }
+    tp = endp;
+  }
+  if (tp != endp)
+    return UV_EINVAL;
+  memcpy(dst, tmp, sizeof tmp);
+  return 0;
+}

deps/uv/src/queue.h

@@ -0,0 +1,90 @@
+/* Copyright (c) 2013, Ben Noordhuis <info@bnoordhuis.nl>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef QUEUE_H_
+#define QUEUE_H_
+
+#include <stddef.h>
+
+#define uv__queue_data(pointer, type, field)                                  \
+  ((type*) ((char*) (pointer) - offsetof(type, field)))
+
+#define uv__queue_foreach(q, h)                                               \
+  for ((q) = (h)->next; (q) != (h); (q) = (q)->next)
+
+static inline void uv__queue_init(struct uv__queue* q) {
+  q->next = q;
+  q->prev = q;
+}
+
+static inline int uv__queue_empty(const struct uv__queue* q) {
+  return q == q->next;
+}
+
+static inline struct uv__queue* uv__queue_head(const struct uv__queue* q) {
+  return q->next;
+}
+
+static inline struct uv__queue* uv__queue_next(const struct uv__queue* q) {
+  return q->next;
+}
+
+static inline void uv__queue_add(struct uv__queue* h, struct uv__queue* n) {
+  h->prev->next = n->next;
+  n->next->prev = h->prev;
+  h->prev = n->prev;
+  h->prev->next = h;
+}
+
+static inline void uv__queue_split(struct uv__queue* h,
+                                   struct uv__queue* q,
+                                   struct uv__queue* n) {
+  n->prev = h->prev;
+  n->prev->next = n;
+  n->next = q;
+  h->prev = q->prev;
+  h->prev->next = h;
+  q->prev = n;
+}
+
+static inline void uv__queue_move(struct uv__queue* h, struct uv__queue* n) {
+  if (uv__queue_empty(h))
+    uv__queue_init(n);
+  else
+    uv__queue_split(h, h->next, n);
+}
+
+static inline void uv__queue_insert_head(struct uv__queue* h,
+                                         struct uv__queue* q) {
+  q->next = h->next;
+  q->prev = h;
+  q->next->prev = q;
+  h->next = q;
+}
+
+static inline void uv__queue_insert_tail(struct uv__queue* h,
+                                         struct uv__queue* q) {
+  q->next = h;
+  q->prev = h->prev;
+  q->prev->next = q;
+  h->prev = q;
+}
+
+static inline void uv__queue_remove(struct uv__queue* q) {
+  q->prev->next = q->next;
+  q->next->prev = q->prev;
+}
+
+#endif /* QUEUE_H_ */