@openclaw/slack 2026.7.2-beta.4 → 2026.7.2-beta.5

package/node_modules/@types/ws/index.d.ts

@@ -1,445 +0,0 @@
-/// <reference types="node" />
-
-import { EventEmitter } from "events";
-import {
-    Agent,
-    ClientRequest,
-    ClientRequestArgs,
-    IncomingMessage,
-    OutgoingHttpHeaders,
-    Server as HTTPServer,
-} from "http";
-import { Server as HTTPSServer } from "https";
-import { createConnection } from "net";
-import { Duplex, DuplexOptions } from "stream";
-import { SecureContextOptions } from "tls";
-import { URL } from "url";
-import { ZlibOptions } from "zlib";
-
-// can not get all overload of BufferConstructor['from'], need to copy all it's first arguments here
-// https://github.com/microsoft/TypeScript/issues/32164
-type BufferLike =
-    | string
-    | Buffer
-    | DataView
-    | number
-    | ArrayBufferView
-    | Uint8Array
-    | ArrayBuffer
-    | SharedArrayBuffer
-    | Blob
-    | readonly any[]
-    | readonly number[]
-    | { valueOf(): ArrayBuffer }
-    | { valueOf(): SharedArrayBuffer }
-    | { valueOf(): Uint8Array }
-    | { valueOf(): readonly number[] }
-    | { valueOf(): string }
-    | { [Symbol.toPrimitive](hint: string): string };
-
-// WebSocket socket.
-declare class WebSocket extends EventEmitter {
-    /** The connection is not yet open. */
-    static readonly CONNECTING: 0;
-    /** The connection is open and ready to communicate. */
-    static readonly OPEN: 1;
-    /** The connection is in the process of closing. */
-    static readonly CLOSING: 2;
-    /** The connection is closed. */
-    static readonly CLOSED: 3;
-
-    binaryType: "nodebuffer" | "arraybuffer" | "fragments";
-    readonly bufferedAmount: number;
-    readonly extensions: string;
-    /** Indicates whether the websocket is paused */
-    readonly isPaused: boolean;
-    readonly protocol: string;
-    /** The current state of the connection */
-    readonly readyState:
-        | typeof WebSocket.CONNECTING
-        | typeof WebSocket.OPEN
-        | typeof WebSocket.CLOSING
-        | typeof WebSocket.CLOSED;
-    readonly url: string;
-
-    /** The connection is not yet open. */
-    readonly CONNECTING: 0;
-    /** The connection is open and ready to communicate. */
-    readonly OPEN: 1;
-    /** The connection is in the process of closing. */
-    readonly CLOSING: 2;
-    /** The connection is closed. */
-    readonly CLOSED: 3;
-
-    onopen: ((event: WebSocket.Event) => void) | null;
-    onerror: ((event: WebSocket.ErrorEvent) => void) | null;
-    onclose: ((event: WebSocket.CloseEvent) => void) | null;
-    onmessage: ((event: WebSocket.MessageEvent) => void) | null;
-
-    constructor(address: null);
-    constructor(address: string | URL, options?: WebSocket.ClientOptions | ClientRequestArgs);
-    constructor(
-        address: string | URL,
-        protocols?: string | string[],
-        options?: WebSocket.ClientOptions | ClientRequestArgs,
-    );
-
-    close(code?: number, data?: string | Buffer): void;
-    ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
-    pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
-    // https://github.com/websockets/ws/issues/2076#issuecomment-1250354722
-    send(data: BufferLike, cb?: (err?: Error) => void): void;
-    send(
-        data: BufferLike,
-        options: {
-            mask?: boolean | undefined;
-            binary?: boolean | undefined;
-            compress?: boolean | undefined;
-            fin?: boolean | undefined;
-        },
-        cb?: (err?: Error) => void,
-    ): void;
-    terminate(): void;
-
-    /**
-     * Pause the websocket causing it to stop emitting events. Some events can still be
-     * emitted after this is called, until all buffered data is consumed. This method
-     * is a noop if the ready state is `CONNECTING` or `CLOSED`.
-     */
-    pause(): void;
-    /**
-     * Make a paused socket resume emitting events. This method is a noop if the ready
-     * state is `CONNECTING` or `CLOSED`.
-     */
-    resume(): void;
-
-    // HTML5 WebSocket events
-    addEventListener<K extends keyof WebSocket.WebSocketEventMap>(
-        type: K,
-        listener:
-            | ((event: WebSocket.WebSocketEventMap[K]) => void)
-            | { handleEvent(event: WebSocket.WebSocketEventMap[K]): void },
-        options?: WebSocket.EventListenerOptions,
-    ): void;
-    removeEventListener<K extends keyof WebSocket.WebSocketEventMap>(
-        type: K,
-        listener:
-            | ((event: WebSocket.WebSocketEventMap[K]) => void)
-            | { handleEvent(event: WebSocket.WebSocketEventMap[K]): void },
-    ): void;
-
-    // Events
-    on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    on(event: "error", listener: (this: WebSocket, error: Error) => void): this;
-    on(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    on(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    on(event: "open", listener: (this: WebSocket) => void): this;
-    on(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
-    on(event: "redirect", listener: (this: WebSocket, url: string, request: ClientRequest) => void): this;
-    on(
-        event: "unexpected-response",
-        listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void,
-    ): this;
-    on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-
-    once(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    once(event: "error", listener: (this: WebSocket, error: Error) => void): this;
-    once(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    once(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    once(event: "open", listener: (this: WebSocket) => void): this;
-    once(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
-    once(event: "redirect", listener: (this: WebSocket, url: string, request: ClientRequest) => void): this;
-    once(
-        event: "unexpected-response",
-        listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void,
-    ): this;
-    once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-
-    off(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this;
-    off(event: "error", listener: (this: WebSocket, error: Error) => void): this;
-    off(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this;
-    off(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this;
-    off(event: "open", listener: (this: WebSocket) => void): this;
-    off(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this;
-    off(event: "redirect", listener: (this: WebSocket, url: string, request: ClientRequest) => void): this;
-    off(
-        event: "unexpected-response",
-        listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void,
-    ): this;
-    off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this;
-
-    addListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
-    addListener(event: "error", listener: (error: Error) => void): this;
-    addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
-    addListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
-    addListener(event: "open", listener: () => void): this;
-    addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
-    addListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
-    addListener(
-        event: "unexpected-response",
-        listener: (request: ClientRequest, response: IncomingMessage) => void,
-    ): this;
-    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-    removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this;
-    removeListener(event: "error", listener: (error: Error) => void): this;
-    removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this;
-    removeListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this;
-    removeListener(event: "open", listener: () => void): this;
-    removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this;
-    removeListener(event: "redirect", listener: (url: string, request: ClientRequest) => void): this;
-    removeListener(
-        event: "unexpected-response",
-        listener: (request: ClientRequest, response: IncomingMessage) => void,
-    ): this;
-    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-}
-
-declare const WebSocketAlias: typeof WebSocket;
-interface WebSocketAlias extends WebSocket {} // eslint-disable-line @typescript-eslint/no-empty-interface
-
-declare namespace WebSocket {
-    /**
-     * Data represents the raw message payload received over the WebSocket.
-     */
-    type RawData = Buffer | ArrayBuffer | Buffer[];
-
-    /**
-     * Data represents the message payload received over the WebSocket.
-     */
-    type Data = string | Buffer | ArrayBuffer | Buffer[];
-
-    /**
-     * CertMeta represents the accepted types for certificate & key data.
-     */
-    type CertMeta = string | string[] | Buffer | Buffer[];
-
-    /**
-     * VerifyClientCallbackSync is a synchronous callback used to inspect the
-     * incoming message. The return value (boolean) of the function determines
-     * whether or not to accept the handshake.
-     */
-    type VerifyClientCallbackSync<Request extends IncomingMessage = IncomingMessage> = (info: {
-        origin: string;
-        secure: boolean;
-        req: Request;
-    }) => boolean;
-
-    /**
-     * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
-     * incoming message. The return value (boolean) of the function determines
-     * whether or not to accept the handshake.
-     */
-    type VerifyClientCallbackAsync<Request extends IncomingMessage = IncomingMessage> = (
-        info: { origin: string; secure: boolean; req: Request },
-        callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void,
-    ) => void;
-
-    /**
-     * FinishRequestCallback is a callback for last minute customization of the
-     * headers. If finishRequest is set, then it has the responsibility to call
-     * request.end() once it is done setting request headers.
-     */
-    type FinishRequestCallback = (request: ClientRequest, websocket: WebSocket) => void;
-
-    interface ClientOptions extends SecureContextOptions {
-        protocol?: string | undefined;
-        followRedirects?: boolean | undefined;
-        generateMask?(mask: Buffer): void;
-        handshakeTimeout?: number | undefined;
-        maxRedirects?: number | undefined;
-        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
-        localAddress?: string | undefined;
-        protocolVersion?: number | undefined;
-        headers?: { [key: string]: string } | undefined;
-        origin?: string | undefined;
-        agent?: Agent | undefined;
-        host?: string | undefined;
-        family?: number | undefined;
-        checkServerIdentity?(servername: string, cert: CertMeta): boolean;
-        rejectUnauthorized?: boolean | undefined;
-        allowSynchronousEvents?: boolean | undefined;
-        autoPong?: boolean | undefined;
-        maxPayload?: number | undefined;
-        skipUTF8Validation?: boolean | undefined;
-        createConnection?: typeof createConnection | undefined;
-        finishRequest?: FinishRequestCallback | undefined;
-    }
-
-    interface PerMessageDeflateOptions {
-        serverNoContextTakeover?: boolean | undefined;
-        clientNoContextTakeover?: boolean | undefined;
-        serverMaxWindowBits?: number | undefined;
-        clientMaxWindowBits?: number | undefined;
-        zlibDeflateOptions?: {
-            flush?: number | undefined;
-            finishFlush?: number | undefined;
-            chunkSize?: number | undefined;
-            windowBits?: number | undefined;
-            level?: number | undefined;
-            memLevel?: number | undefined;
-            strategy?: number | undefined;
-            dictionary?: Buffer | Buffer[] | DataView | undefined;
-            info?: boolean | undefined;
-        } | undefined;
-        zlibInflateOptions?: ZlibOptions | undefined;
-        threshold?: number | undefined;
-        concurrencyLimit?: number | undefined;
-    }
-
-    interface Event {
-        type: string;
-        target: WebSocket;
-    }
-
-    interface ErrorEvent {
-        error: any;
-        message: string;
-        type: string;
-        target: WebSocket;
-    }
-
-    interface CloseEvent {
-        wasClean: boolean;
-        code: number;
-        reason: string;
-        type: string;
-        target: WebSocket;
-    }
-
-    interface MessageEvent {
-        data: Data;
-        type: string;
-        target: WebSocket;
-    }
-
-    interface WebSocketEventMap {
-        open: Event;
-        error: ErrorEvent;
-        close: CloseEvent;
-        message: MessageEvent;
-    }
-
-    interface EventListenerOptions {
-        once?: boolean | undefined;
-    }
-
-    interface ServerOptions<
-        U extends typeof WebSocket.WebSocket = typeof WebSocket.WebSocket,
-        V extends typeof IncomingMessage = typeof IncomingMessage,
-    > {
-        host?: string | undefined;
-        port?: number | undefined;
-        backlog?: number | undefined;
-        server?: HTTPServer<V> | HTTPSServer<V> | undefined;
-        verifyClient?:
-            | VerifyClientCallbackAsync<InstanceType<V>>
-            | VerifyClientCallbackSync<InstanceType<V>>
-            | undefined;
-        handleProtocols?: (protocols: Set<string>, request: InstanceType<V>) => string | false;
-        path?: string | undefined;
-        noServer?: boolean | undefined;
-        allowSynchronousEvents?: boolean | undefined;
-        autoPong?: boolean | undefined;
-        clientTracking?: boolean | undefined;
-        perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
-        maxPayload?: number | undefined;
-        skipUTF8Validation?: boolean | undefined;
-        WebSocket?: U | undefined;
-    }
-
-    interface AddressInfo {
-        address: string;
-        family: string;
-        port: number;
-    }
-
-    // WebSocket Server
-    class Server<
-        T extends typeof WebSocket.WebSocket = typeof WebSocket.WebSocket,
-        U extends typeof IncomingMessage = typeof IncomingMessage,
-    > extends EventEmitter {
-        options: ServerOptions<T, U>;
-        path: string;
-        clients: Set<InstanceType<T>>;
-
-        constructor(options?: ServerOptions<T, U>, callback?: () => void);
-
-        address(): AddressInfo | string | null;
-        close(cb?: (err?: Error) => void): void;
-        handleUpgrade(
-            request: InstanceType<U>,
-            socket: Duplex,
-            upgradeHead: Buffer,
-            callback: (client: InstanceType<T>, request: InstanceType<U>) => void,
-        ): void;
-        shouldHandle(request: InstanceType<U>): boolean | Promise<boolean>;
-
-        // Events
-        on(
-            event: "connection",
-            cb: (this: Server<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void,
-        ): this;
-        on(event: "error", cb: (this: Server<T>, error: Error) => void): this;
-        on(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
-        on(event: "close" | "listening", cb: (this: Server<T>) => void): this;
-        on(
-            event: "wsClientError",
-            cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
-        ): this;
-        on(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-
-        once(
-            event: "connection",
-            cb: (this: Server<T>, websocket: InstanceType<T>, request: InstanceType<U>) => void,
-        ): this;
-        once(event: "error", cb: (this: Server<T>, error: Error) => void): this;
-        once(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
-        once(event: "close" | "listening", cb: (this: Server<T>) => void): this;
-        once(
-            event: "wsClientError",
-            cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
-        ): this;
-        once(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-
-        off(
-            event: "connection",
-            cb: (this: Server<T>, socket: InstanceType<T>, request: InstanceType<U>) => void,
-        ): this;
-        off(event: "error", cb: (this: Server<T>, error: Error) => void): this;
-        off(event: "headers", cb: (this: Server<T>, headers: string[], request: InstanceType<U>) => void): this;
-        off(event: "close" | "listening", cb: (this: Server<T>) => void): this;
-        off(
-            event: "wsClientError",
-            cb: (this: Server<T>, error: Error, socket: Duplex, request: InstanceType<U>) => void,
-        ): this;
-        off(event: string | symbol, listener: (this: Server<T>, ...args: any[]) => void): this;
-
-        addListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
-        addListener(event: "error", cb: (error: Error) => void): this;
-        addListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
-        addListener(event: "close" | "listening", cb: () => void): this;
-        addListener(event: "wsClientError", cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-
-        removeListener(event: "connection", cb: (websocket: InstanceType<T>, request: InstanceType<U>) => void): this;
-        removeListener(event: "error", cb: (error: Error) => void): this;
-        removeListener(event: "headers", cb: (headers: string[], request: InstanceType<U>) => void): this;
-        removeListener(event: "close" | "listening", cb: () => void): this;
-        removeListener(
-            event: "wsClientError",
-            cb: (error: Error, socket: Duplex, request: InstanceType<U>) => void,
-        ): this;
-        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-    }
-
-    const WebSocketServer: typeof Server;
-    interface WebSocketServer extends Server {} // eslint-disable-line @typescript-eslint/no-empty-interface
-    const WebSocket: typeof WebSocketAlias;
-    interface WebSocket extends WebSocketAlias {} // eslint-disable-line @typescript-eslint/no-empty-interface
-
-    // WebSocket stream
-    function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex;
-}
-
-export = WebSocket;

package/node_modules/@types/ws/package.json

@@ -1,72 +0,0 @@
-{
-    "name": "@types/ws",
-    "version": "8.18.1",
-    "description": "TypeScript definitions for ws",
-    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ws",
-    "license": "MIT",
-    "contributors": [
-        {
-            "name": "Paul Loyd",
-            "githubUsername": "loyd",
-            "url": "https://github.com/loyd"
-        },
-        {
-            "name": "Margus Lamp",
-            "githubUsername": "mlamp",
-            "url": "https://github.com/mlamp"
-        },
-        {
-            "name": "Philippe D'Alva",
-            "githubUsername": "TitaneBoy",
-            "url": "https://github.com/TitaneBoy"
-        },
-        {
-            "name": "reduckted",
-            "githubUsername": "reduckted",
-            "url": "https://github.com/reduckted"
-        },
-        {
-            "name": "teidesu",
-            "githubUsername": "teidesu",
-            "url": "https://github.com/teidesu"
-        },
-        {
-            "name": "Bartosz Wojtkowiak",
-            "githubUsername": "wojtkowiak",
-            "url": "https://github.com/wojtkowiak"
-        },
-        {
-            "name": "Kyle Hensel",
-            "githubUsername": "k-yle",
-            "url": "https://github.com/k-yle"
-        },
-        {
-            "name": "Samuel Skeen",
-            "githubUsername": "cwadrupldijjit",
-            "url": "https://github.com/cwadrupldijjit"
-        }
-    ],
-    "main": "",
-    "types": "index.d.ts",
-    "exports": {
-        ".": {
-            "types": {
-                "import": "./index.d.mts",
-                "default": "./index.d.ts"
-            }
-        },
-        "./package.json": "./package.json"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
-        "directory": "types/ws"
-    },
-    "scripts": {},
-    "dependencies": {
-        "@types/node": "*"
-    },
-    "peerDependencies": {},
-    "typesPublisherContentHash": "043c83a4bb92503ab01243879ee715fb6db391090d10883c5a2eb72099d22724",
-    "typeScriptVersion": "5.1"
-}

package/node_modules/agent-base/README.md

@@ -1,145 +0,0 @@
-agent-base
-==========
-### Turn a function into an [`http.Agent`][http.Agent] instance
-[![Build Status](https://github.com/TooTallNate/node-agent-base/workflows/Node%20CI/badge.svg)](https://github.com/TooTallNate/node-agent-base/actions?workflow=Node+CI)
-
-This module provides an `http.Agent` generator. That is, you pass it an async
-callback function, and it returns a new `http.Agent` instance that will invoke the
-given callback function when sending outbound HTTP requests.
-
-#### Some subclasses:
-
-Here's some more interesting uses of `agent-base`.
-Send a pull request to list yours!
-
- * [`http-proxy-agent`][http-proxy-agent]: An HTTP(s) proxy `http.Agent` implementation for HTTP endpoints
- * [`https-proxy-agent`][https-proxy-agent]: An HTTP(s) proxy `http.Agent` implementation for HTTPS endpoints
- * [`pac-proxy-agent`][pac-proxy-agent]: A PAC file proxy `http.Agent` implementation for HTTP and HTTPS
- * [`socks-proxy-agent`][socks-proxy-agent]: A SOCKS proxy `http.Agent` implementation for HTTP and HTTPS
-
-
-Installation
-------------
-
-Install with `npm`:
-
-``` bash
-$ npm install agent-base
-```
-
-
-Example
--------
-
-Here's a minimal example that creates a new `net.Socket` connection to the server
-for every HTTP request (i.e. the equivalent of `agent: false` option):
-
-```js
-var net = require('net');
-var tls = require('tls');
-var url = require('url');
-var http = require('http');
-var agent = require('agent-base');
-
-var endpoint = 'http://nodejs.org/api/';
-var parsed = url.parse(endpoint);
-
-// This is the important part!
-parsed.agent = agent(function (req, opts) {
-  var socket;
-  // `secureEndpoint` is true when using the https module
-  if (opts.secureEndpoint) {
-    socket = tls.connect(opts);
-  } else {
-    socket = net.connect(opts);
-  }
-  return socket;
-});
-
-// Everything else works just like normal...
-http.get(parsed, function (res) {
-  console.log('"response" event!', res.headers);
-  res.pipe(process.stdout);
-});
-```
-
-Returning a Promise or using an `async` function is also supported:
-
-```js
-agent(async function (req, opts) {
-  await sleep(1000);
-  // etc…
-});
-```
-
-Return another `http.Agent` instance to "pass through" the responsibility
-for that HTTP request to that agent:
-
-```js
-agent(function (req, opts) {
-  return opts.secureEndpoint ? https.globalAgent : http.globalAgent;
-});
-```
-
-
-API
----
-
-## Agent(Function callback[, Object options]) → [http.Agent][]
-
-Creates a base `http.Agent` that will execute the callback function `callback`
-for every HTTP request that it is used as the `agent` for. The callback function
-is responsible for creating a `stream.Duplex` instance of some kind that will be
-used as the underlying socket in the HTTP request.
-
-The `options` object accepts the following properties:
-
-  * `timeout` - Number - Timeout for the `callback()` function in milliseconds. Defaults to Infinity (optional).
-
-The callback function should have the following signature:
-
-### callback(http.ClientRequest req, Object options, Function cb) → undefined
-
-The ClientRequest `req` can be accessed to read request headers and
-and the path, etc. The `options` object contains the options passed
-to the `http.request()`/`https.request()` function call, and is formatted
-to be directly passed to `net.connect()`/`tls.connect()`, or however
-else you want a Socket to be created. Pass the created socket to
-the callback function `cb` once created, and the HTTP request will
-continue to proceed.
-
-If the `https` module is used to invoke the HTTP request, then the
-`secureEndpoint` property on `options` _will be set to `true`_.
-
-
-License
--------
-
-(The MIT License)
-
-Copyright (c) 2013 Nathan Rajlich <nathan@tootallnate.net>
-
-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.
-
-[http-proxy-agent]: https://github.com/TooTallNate/node-http-proxy-agent
-[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
-[pac-proxy-agent]: https://github.com/TooTallNate/node-pac-proxy-agent
-[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
-[http.Agent]: https://nodejs.org/api/http.html#http_class_http_agent