@nocobase/plugin-multi-app-manager 2.1.0-alpha.1 → 2.1.0-alpha.11

package/dist/node_modules/mariadb/node_modules/@types/node/https.d.ts

@@ -1,391 +0,0 @@
-/**
- * HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
- * separate module.
- * @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/https.js)
- */
-declare module 'https' {
-    import { Duplex } from 'node:stream';
-    import * as tls from 'node:tls';
-    import * as http from 'node:http';
-    import { URL } from 'node:url';
-    type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
-    type RequestOptions = http.RequestOptions &
-        tls.SecureContextOptions & {
-            rejectUnauthorized?: boolean | undefined; // Defaults to true
-            servername?: string | undefined; // SNI TLS Extension
-        };
-    interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
-        rejectUnauthorized?: boolean | undefined;
-        maxCachedSessions?: number | undefined;
-    }
-    /**
-     * An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
-     * @since v0.4.5
-     */
-    class Agent extends http.Agent {
-        constructor(options?: AgentOptions);
-        options: AgentOptions;
-    }
-    interface Server extends http.Server {}
-    /**
-     * See `http.Server` for more information.
-     * @since v0.3.4
-     */
-    class Server extends tls.Server {
-        constructor(requestListener?: http.RequestListener);
-        constructor(options: ServerOptions, requestListener?: http.RequestListener);
-        addListener(event: string, listener: (...args: any[]) => void): this;
-        addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
-        addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        addListener(event: 'close', listener: () => void): this;
-        addListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        addListener(event: 'error', listener: (err: Error) => void): this;
-        addListener(event: 'listening', listener: () => void): this;
-        addListener(event: 'checkContinue', listener: http.RequestListener): this;
-        addListener(event: 'checkExpectation', listener: http.RequestListener): this;
-        addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        addListener(event: 'request', listener: http.RequestListener): this;
-        addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        emit(event: string, ...args: any[]): boolean;
-        emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
-        emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
-        emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
-        emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
-        emit(event: 'close'): boolean;
-        emit(event: 'connection', socket: Duplex): boolean;
-        emit(event: 'error', err: Error): boolean;
-        emit(event: 'listening'): boolean;
-        emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'clientError', err: Error, socket: Duplex): boolean;
-        emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
-        emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
-        emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
-        on(event: string, listener: (...args: any[]) => void): this;
-        on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
-        on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        on(event: 'close', listener: () => void): this;
-        on(event: 'connection', listener: (socket: Duplex) => void): this;
-        on(event: 'error', listener: (err: Error) => void): this;
-        on(event: 'listening', listener: () => void): this;
-        on(event: 'checkContinue', listener: http.RequestListener): this;
-        on(event: 'checkExpectation', listener: http.RequestListener): this;
-        on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        on(event: 'request', listener: http.RequestListener): this;
-        on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        once(event: string, listener: (...args: any[]) => void): this;
-        once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
-        once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        once(event: 'close', listener: () => void): this;
-        once(event: 'connection', listener: (socket: Duplex) => void): this;
-        once(event: 'error', listener: (err: Error) => void): this;
-        once(event: 'listening', listener: () => void): this;
-        once(event: 'checkContinue', listener: http.RequestListener): this;
-        once(event: 'checkExpectation', listener: http.RequestListener): this;
-        once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        once(event: 'request', listener: http.RequestListener): this;
-        once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: string, listener: (...args: any[]) => void): this;
-        prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
-        prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependListener(event: 'close', listener: () => void): this;
-        prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        prependListener(event: 'error', listener: (err: Error) => void): this;
-        prependListener(event: 'listening', listener: () => void): this;
-        prependListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
-        prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependListener(event: 'request', listener: http.RequestListener): this;
-        prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
-        prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
-        prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
-        prependOnceListener(event: 'close', listener: () => void): this;
-        prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
-        prependOnceListener(event: 'error', listener: (err: Error) => void): this;
-        prependOnceListener(event: 'listening', listener: () => void): this;
-        prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
-        prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
-        prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
-        prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-        prependOnceListener(event: 'request', listener: http.RequestListener): this;
-        prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
-    }
-    /**
-     * ```js
-     * // curl -k https://localhost:8000/
-     * const https = require('https');
-     * const fs = require('fs');
-     *
-     * const options = {
-     *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
-     * };
-     *
-     * https.createServer(options, (req, res) => {
-     *   res.writeHead(200);
-     *   res.end('hello world\n');
-     * }).listen(8000);
-     * ```
-     *
-     * Or
-     *
-     * ```js
-     * const https = require('https');
-     * const fs = require('fs');
-     *
-     * const options = {
-     *   pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
-     *   passphrase: 'sample'
-     * };
-     *
-     * https.createServer(options, (req, res) => {
-     *   res.writeHead(200);
-     *   res.end('hello world\n');
-     * }).listen(8000);
-     * ```
-     * @since v0.3.4
-     * @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
-     * @param requestListener A listener to be added to the `'request'` event.
-     */
-    function createServer(requestListener?: http.RequestListener): Server;
-    function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
-    /**
-     * Makes a request to a secure web server.
-     *
-     * The following additional `options` from `tls.connect()` are also accepted:`ca`, `cert`, `ciphers`, `clientCertEngine`, `crl`, `dhparam`, `ecdhCurve`,`honorCipherOrder`, `key`, `passphrase`,
-     * `pfx`, `rejectUnauthorized`,`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`,`highWaterMark`.
-     *
-     * `options` can be an object, a string, or a `URL` object. If `options` is a
-     * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
-     *
-     * `https.request()` returns an instance of the `http.ClientRequest` class. The `ClientRequest` instance is a writable stream. If one needs to
-     * upload a file with a POST request, then write to the `ClientRequest` object.
-     *
-     * ```js
-     * const https = require('https');
-     *
-     * const options = {
-     *   hostname: 'encrypted.google.com',
-     *   port: 443,
-     *   path: '/',
-     *   method: 'GET'
-     * };
-     *
-     * const req = https.request(options, (res) => {
-     *   console.log('statusCode:', res.statusCode);
-     *   console.log('headers:', res.headers);
-     *
-     *   res.on('data', (d) => {
-     *     process.stdout.write(d);
-     *   });
-     * });
-     *
-     * req.on('error', (e) => {
-     *   console.error(e);
-     * });
-     * req.end();
-     * ```
-     *
-     * Example using options from `tls.connect()`:
-     *
-     * ```js
-     * const options = {
-     *   hostname: 'encrypted.google.com',
-     *   port: 443,
-     *   path: '/',
-     *   method: 'GET',
-     *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
-     * };
-     * options.agent = new https.Agent(options);
-     *
-     * const req = https.request(options, (res) => {
-     *   // ...
-     * });
-     * ```
-     *
-     * Alternatively, opt out of connection pooling by not using an `Agent`.
-     *
-     * ```js
-     * const options = {
-     *   hostname: 'encrypted.google.com',
-     *   port: 443,
-     *   path: '/',
-     *   method: 'GET',
-     *   key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
-     *   cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
-     *   agent: false
-     * };
-     *
-     * const req = https.request(options, (res) => {
-     *   // ...
-     * });
-     * ```
-     *
-     * Example using a `URL` as `options`:
-     *
-     * ```js
-     * const options = new URL('https://abc:xyz@example.com');
-     *
-     * const req = https.request(options, (res) => {
-     *   // ...
-     * });
-     * ```
-     *
-     * Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
-     *
-     * ```js
-     * const tls = require('tls');
-     * const https = require('https');
-     * const crypto = require('crypto');
-     *
-     * function sha256(s) {
-     *   return crypto.createHash('sha256').update(s).digest('base64');
-     * }
-     * const options = {
-     *   hostname: 'github.com',
-     *   port: 443,
-     *   path: '/',
-     *   method: 'GET',
-     *   checkServerIdentity: function(host, cert) {
-     *     // Make sure the certificate is issued to the host we are connected to
-     *     const err = tls.checkServerIdentity(host, cert);
-     *     if (err) {
-     *       return err;
-     *     }
-     *
-     *     // Pin the public key, similar to HPKP pin-sha25 pinning
-     *     const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
-     *     if (sha256(cert.pubkey) !== pubkey256) {
-     *       const msg = 'Certificate verification error: ' +
-     *         `The public key of '${cert.subject.CN}' ` +
-     *         'does not match our pinned fingerprint';
-     *       return new Error(msg);
-     *     }
-     *
-     *     // Pin the exact certificate, rather than the pub key
-     *     const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +
-     *       'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';
-     *     if (cert.fingerprint256 !== cert256) {
-     *       const msg = 'Certificate verification error: ' +
-     *         `The certificate of '${cert.subject.CN}' ` +
-     *         'does not match our pinned fingerprint';
-     *       return new Error(msg);
-     *     }
-     *
-     *     // This loop is informational only.
-     *     // Print the certificate and public key fingerprints of all certs in the
-     *     // chain. Its common to pin the public key of the issuer on the public
-     *     // internet, while pinning the public key of the service in sensitive
-     *     // environments.
-     *     do {
-     *       console.log('Subject Common Name:', cert.subject.CN);
-     *       console.log('  Certificate SHA256 fingerprint:', cert.fingerprint256);
-     *
-     *       hash = crypto.createHash('sha256');
-     *       console.log('  Public key ping-sha256:', sha256(cert.pubkey));
-     *
-     *       lastprint256 = cert.fingerprint256;
-     *       cert = cert.issuerCertificate;
-     *     } while (cert.fingerprint256 !== lastprint256);
-     *
-     *   },
-     * };
-     *
-     * options.agent = new https.Agent(options);
-     * const req = https.request(options, (res) => {
-     *   console.log('All OK. Server matched our pinned cert or public key');
-     *   console.log('statusCode:', res.statusCode);
-     *   // Print the HPKP values
-     *   console.log('headers:', res.headers['public-key-pins']);
-     *
-     *   res.on('data', (d) => {});
-     * });
-     *
-     * req.on('error', (e) => {
-     *   console.error(e.message);
-     * });
-     * req.end();
-     * ```
-     *
-     * Outputs for example:
-     *
-     * ```text
-     * Subject Common Name: github.com
-     *   Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
-     *   Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=
-     * Subject Common Name: DigiCert SHA2 Extended Validation Server CA
-     *   Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A
-     *   Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=
-     * Subject Common Name: DigiCert High Assurance EV Root CA
-     *   Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF
-     *   Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
-     * All OK. Server matched our pinned cert or public key
-     * statusCode: 200
-     * headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=";
-     * pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=";
-     * pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains
-     * ```
-     * @since v0.3.6
-     * @param options Accepts all `options` from `request`, with some differences in default values:
-     */
-    function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    /**
-     * Like `http.get()` but for HTTPS.
-     *
-     * `options` can be an object, a string, or a `URL` object. If `options` is a
-     * string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
-     *
-     * ```js
-     * const https = require('https');
-     *
-     * https.get('https://encrypted.google.com/', (res) => {
-     *   console.log('statusCode:', res.statusCode);
-     *   console.log('headers:', res.headers);
-     *
-     *   res.on('data', (d) => {
-     *     process.stdout.write(d);
-     *   });
-     *
-     * }).on('error', (e) => {
-     *   console.error(e);
-     * });
-     * ```
-     * @since v0.3.6
-     * @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
-     */
-    function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
-    let globalAgent: Agent;
-}
-declare module 'node:https' {
-    export * from 'https';
-}

package/dist/node_modules/mariadb/node_modules/@types/node/index.d.ts

@@ -1,129 +0,0 @@
-// Type definitions for non-npm package Node.js 17.0
-// Project: https://nodejs.org/
-// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
-//                 DefinitelyTyped <https://github.com/DefinitelyTyped>
-//                 Alberto Schiabel <https://github.com/jkomyno>
-//                 Alvis HT Tang <https://github.com/alvis>
-//                 Andrew Makarov <https://github.com/r3nya>
-//                 Benjamin Toueg <https://github.com/btoueg>
-//                 Chigozirim C. <https://github.com/smac89>
-//                 David Junger <https://github.com/touffy>
-//                 Deividas Bakanas <https://github.com/DeividasBakanas>
-//                 Eugene Y. Q. Shen <https://github.com/eyqs>
-//                 Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>
-//                 Huw <https://github.com/hoo29>
-//                 Kelvin Jin <https://github.com/kjin>
-//                 Klaus Meinhardt <https://github.com/ajafff>
-//                 Lishude <https://github.com/islishude>
-//                 Mariusz Wiktorczyk <https://github.com/mwiktorczyk>
-//                 Mohsen Azimi <https://github.com/mohsen1>
-//                 Nicolas Even <https://github.com/n-e>
-//                 Nikita Galkin <https://github.com/galkin>
-//                 Parambir Singh <https://github.com/parambirs>
-//                 Sebastian Silbermann <https://github.com/eps1lon>
-//                 Simon Schick <https://github.com/SimonSchick>
-//                 Thomas den Hollander <https://github.com/ThomasdenH>
-//                 Wilco Bakker <https://github.com/WilcoBakker>
-//                 wwwy3y3 <https://github.com/wwwy3y3>
-//                 Samuel Ainsworth <https://github.com/samuela>
-//                 Kyle Uehlein <https://github.com/kuehlein>
-//                 Thanik Bhongbhibhat <https://github.com/bhongy>
-//                 Marcin Kopacz <https://github.com/chyzwar>
-//                 Trivikram Kamat <https://github.com/trivikr>
-//                 Junxiao Shi <https://github.com/yoursunny>
-//                 Ilia Baryshnikov <https://github.com/qwelias>
-//                 ExE Boss <https://github.com/ExE-Boss>
-//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
-//                 Anna Henningsen <https://github.com/addaleax>
-//                 Victor Perin <https://github.com/victorperin>
-//                 Yongsheng Zhang <https://github.com/ZYSzys>
-//                 NodeJS Contributors <https://github.com/NodeJS>
-//                 Linus Unnebäck <https://github.com/LinusU>
-//                 wafuwafu13 <https://github.com/wafuwafu13>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
-/**
- * License for programmatically and manually incorporated
- * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc
- *
- * Copyright Node.js contributors. All rights reserved.
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-// NOTE: These definitions support NodeJS and TypeScript 3.7+.
-
-// Reference required types from the default lib:
-/// <reference lib="es2020" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.intl" />
-/// <reference lib="esnext.bigint" />
-
-// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
-/// <reference path="assert.d.ts" />
-/// <reference path="assert/strict.d.ts" />
-/// <reference path="globals.d.ts" />
-/// <reference path="async_hooks.d.ts" />
-/// <reference path="buffer.d.ts" />
-/// <reference path="child_process.d.ts" />
-/// <reference path="cluster.d.ts" />
-/// <reference path="console.d.ts" />
-/// <reference path="constants.d.ts" />
-/// <reference path="crypto.d.ts" />
-/// <reference path="dgram.d.ts" />
-/// <reference path="diagnostics_channel.d.ts" />
-/// <reference path="dns.d.ts" />
-/// <reference path="dns/promises.d.ts" />
-/// <reference path="dns/promises.d.ts" />
-/// <reference path="domain.d.ts" />
-/// <reference path="events.d.ts" />
-/// <reference path="fs.d.ts" />
-/// <reference path="fs/promises.d.ts" />
-/// <reference path="http.d.ts" />
-/// <reference path="http2.d.ts" />
-/// <reference path="https.d.ts" />
-/// <reference path="inspector.d.ts" />
-/// <reference path="module.d.ts" />
-/// <reference path="net.d.ts" />
-/// <reference path="os.d.ts" />
-/// <reference path="path.d.ts" />
-/// <reference path="perf_hooks.d.ts" />
-/// <reference path="process.d.ts" />
-/// <reference path="punycode.d.ts" />
-/// <reference path="querystring.d.ts" />
-/// <reference path="readline.d.ts" />
-/// <reference path="repl.d.ts" />
-/// <reference path="stream.d.ts" />
-/// <reference path="stream/promises.d.ts" />
-/// <reference path="stream/consumers.d.ts" />
-/// <reference path="stream/web.d.ts" />
-/// <reference path="string_decoder.d.ts" />
-/// <reference path="timers.d.ts" />
-/// <reference path="timers/promises.d.ts" />
-/// <reference path="tls.d.ts" />
-/// <reference path="trace_events.d.ts" />
-/// <reference path="tty.d.ts" />
-/// <reference path="url.d.ts" />
-/// <reference path="util.d.ts" />
-/// <reference path="v8.d.ts" />
-/// <reference path="vm.d.ts" />
-/// <reference path="wasi.d.ts" />
-/// <reference path="worker_threads.d.ts" />
-/// <reference path="zlib.d.ts" />
-
-/// <reference path="globals.global.d.ts" />