From e4450c8417624b71d779cb4f41692538f9165e10 Mon Sep 17 00:00:00 2001 From: sowgro Date: Sat, 2 Sep 2023 19:12:47 -0400 Subject: first commit --- node_modules/@types/ws/LICENSE | 21 ++ node_modules/@types/ws/README.md | 16 ++ node_modules/@types/ws/index.d.mts | 3 + node_modules/@types/ws/index.d.ts | 411 ++++++++++++++++++++++++++++++++++++ node_modules/@types/ws/package.json | 71 +++++++ 5 files changed, 522 insertions(+) create mode 100755 node_modules/@types/ws/LICENSE create mode 100755 node_modules/@types/ws/README.md create mode 100755 node_modules/@types/ws/index.d.mts create mode 100755 node_modules/@types/ws/index.d.ts create mode 100755 node_modules/@types/ws/package.json (limited to 'node_modules/@types/ws') diff --git a/node_modules/@types/ws/LICENSE b/node_modules/@types/ws/LICENSE new file mode 100755 index 0000000..9e841e7 --- /dev/null +++ b/node_modules/@types/ws/LICENSE @@ -0,0 +1,21 @@ + MIT License + + Copyright (c) Microsoft Corporation. + + 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 diff --git a/node_modules/@types/ws/README.md b/node_modules/@types/ws/README.md new file mode 100755 index 0000000..51a5c50 --- /dev/null +++ b/node_modules/@types/ws/README.md @@ -0,0 +1,16 @@ +# Installation +> `npm install --save @types/ws` + +# Summary +This package contains type definitions for ws (https://github.com/websockets/ws). + +# Details +Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ws. + +### Additional Details + * Last updated: Thu, 08 Jun 2023 20:02:52 GMT + * Dependencies: [@types/node](https://npmjs.com/package/@types/node) + * Global values: none + +# Credits +These definitions were written by [Paul Loyd](https://github.com/loyd), [Margus Lamp](https://github.com/mlamp), [Philippe D'Alva](https://github.com/TitaneBoy), [reduckted](https://github.com/reduckted), [teidesu](https://github.com/teidesu), [Bartosz Wojtkowiak](https://github.com/wojtkowiak), [Kyle Hensel](https://github.com/k-yle), and [Samuel Skeen](https://github.com/cwadrupldijjit). diff --git a/node_modules/@types/ws/index.d.mts b/node_modules/@types/ws/index.d.mts new file mode 100755 index 0000000..a30913c --- /dev/null +++ b/node_modules/@types/ws/index.d.mts @@ -0,0 +1,3 @@ +export { createWebSocketStream, WebSocket, WebSocketServer, RawData, Data, CertMeta, VerifyClientCallbackSync, VerifyClientCallbackAsync, ClientOptions, PerMessageDeflateOptions, Event, ErrorEvent, CloseEvent, MessageEvent, EventListenerOptions, ServerOptions, AddressInfo } from "./index.js"; +import WebSocket = require("./index.js"); +export default WebSocket; \ No newline at end of file diff --git a/node_modules/@types/ws/index.d.ts b/node_modules/@types/ws/index.d.ts new file mode 100755 index 0000000..5cf4748 --- /dev/null +++ b/node_modules/@types/ws/index.d.ts @@ -0,0 +1,411 @@ +// Type definitions for ws 8.5 +// Project: https://github.com/websockets/ws +// Definitions by: Paul Loyd +// Margus Lamp +// Philippe D'Alva +// reduckted +// teidesu +// Bartosz Wojtkowiak +// Kyle Hensel +// Samuel Skeen +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +/// + +import { EventEmitter } from "events"; +import { + Agent, + ClientRequest, + ClientRequestArgs, + IncomingMessage, + OutgoingHttpHeaders, + Server as HTTPServer, +} from "http"; +import { Server as HTTPSServer } from "https"; +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 + | ReadonlyArray + | ReadonlyArray + | { valueOf(): ArrayBuffer } + | { valueOf(): SharedArrayBuffer } + | { valueOf(): Uint8Array } + | { valueOf(): ReadonlyArray } + | { 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( + method: "message", + cb: (event: WebSocket.MessageEvent) => void, + options?: WebSocket.EventListenerOptions, + ): void; + addEventListener( + method: "close", + cb: (event: WebSocket.CloseEvent) => void, + options?: WebSocket.EventListenerOptions, + ): void; + addEventListener( + method: "error", + cb: (event: WebSocket.ErrorEvent) => void, + options?: WebSocket.EventListenerOptions, + ): void; + addEventListener( + method: "open", + cb: (event: WebSocket.Event) => void, + options?: WebSocket.EventListenerOptions, + ): void; + + removeEventListener(method: "message", cb: (event: WebSocket.MessageEvent) => void): void; + removeEventListener(method: "close", cb: (event: WebSocket.CloseEvent) => void): void; + removeEventListener(method: "error", cb: (event: WebSocket.ErrorEvent) => void): void; + removeEventListener(method: "open", cb: (event: WebSocket.Event) => void): void; + + // Events + on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; + on(event: "error", listener: (this: WebSocket, err: 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: "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, err: 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: "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, err: 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: "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: (err: 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: "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: (err: 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: "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 {} // tslint:disable-line 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 = (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 = ( + info: { origin: string; secure: boolean; req: Request }, + callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void, + ) => 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; + maxPayload?: number | undefined; + skipUTF8Validation?: boolean | 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 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 | HTTPSServer | undefined; + verifyClient?: + | VerifyClientCallbackAsync> + | VerifyClientCallbackSync> + | undefined; + handleProtocols?: (protocols: Set, request: InstanceType) => string | false; + path?: string | undefined; + noServer?: 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; + path: string; + clients: Set>; + + constructor(options?: ServerOptions, callback?: () => void); + + address(): AddressInfo | string; + close(cb?: (err?: Error) => void): void; + handleUpgrade( + request: InstanceType, + socket: Duplex, + upgradeHead: Buffer, + callback: (client: InstanceType, request: InstanceType) => void, + ): void; + shouldHandle(request: InstanceType): boolean | Promise; + + // Events + on(event: "connection", cb: (this: Server, socket: InstanceType, request: InstanceType) => void): this; + on(event: "error", cb: (this: Server, error: Error) => void): this; + on(event: "headers", cb: (this: Server, headers: string[], request: InstanceType) => void): this; + on(event: "close" | "listening", cb: (this: Server) => void): this; + on(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; + + once(event: "connection", cb: (this: Server, socket: InstanceType, request: InstanceType) => void): this; + once(event: "error", cb: (this: Server, error: Error) => void): this; + once(event: "headers", cb: (this: Server, headers: string[], request: InstanceType) => void): this; + once(event: "close" | "listening", cb: (this: Server) => void): this; + once(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; + + off(event: "connection", cb: (this: Server, socket: InstanceType, request: InstanceType) => void): this; + off(event: "error", cb: (this: Server, error: Error) => void): this; + off(event: "headers", cb: (this: Server, headers: string[], request: InstanceType) => void): this; + off(event: "close" | "listening", cb: (this: Server) => void): this; + off(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; + + addListener(event: "connection", cb: (client: InstanceType, request: InstanceType) => void): this; + addListener(event: "error", cb: (err: Error) => void): this; + addListener(event: "headers", cb: (headers: string[], request: InstanceType) => void): this; + addListener(event: "close" | "listening", cb: () => void): this; + addListener(event: string | symbol, listener: (...args: any[]) => void): this; + + removeListener(event: "connection", cb: (client: InstanceType, request: InstanceType) => void): this; + removeListener(event: "error", cb: (err: Error) => void): this; + removeListener(event: "headers", cb: (headers: string[], request: InstanceType) => void): this; + removeListener(event: "close" | "listening", cb: () => void): this; + removeListener(event: string | symbol, listener: (...args: any[]) => void): this; + } + + const WebSocketServer: typeof Server; + interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface + const WebSocket: typeof WebSocketAlias; + interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface + + // WebSocket stream + function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex; +} + +export = WebSocket; diff --git a/node_modules/@types/ws/package.json b/node_modules/@types/ws/package.json new file mode 100755 index 0000000..1b945c7 --- /dev/null +++ b/node_modules/@types/ws/package.json @@ -0,0 +1,71 @@ +{ + "name": "@types/ws", + "version": "8.5.5", + "description": "TypeScript definitions for ws", + "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ws", + "license": "MIT", + "contributors": [ + { + "name": "Paul Loyd", + "url": "https://github.com/loyd", + "githubUsername": "loyd" + }, + { + "name": "Margus Lamp", + "url": "https://github.com/mlamp", + "githubUsername": "mlamp" + }, + { + "name": "Philippe D'Alva", + "url": "https://github.com/TitaneBoy", + "githubUsername": "TitaneBoy" + }, + { + "name": "reduckted", + "url": "https://github.com/reduckted", + "githubUsername": "reduckted" + }, + { + "name": "teidesu", + "url": "https://github.com/teidesu", + "githubUsername": "teidesu" + }, + { + "name": "Bartosz Wojtkowiak", + "url": "https://github.com/wojtkowiak", + "githubUsername": "wojtkowiak" + }, + { + "name": "Kyle Hensel", + "url": "https://github.com/k-yle", + "githubUsername": "k-yle" + }, + { + "name": "Samuel Skeen", + "url": "https://github.com/cwadrupldijjit", + "githubUsername": "cwadrupldijjit" + } + ], + "main": "", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", + "directory": "types/ws" + }, + "scripts": {}, + "dependencies": { + "@types/node": "*" + }, + "typesPublisherContentHash": "6eea0ac9982d9cb29e842a5be3f7d3e0103c444a7b96a324c0ce4a86980da93f", + "typeScriptVersion": "4.3", + "exports": { + ".": { + "types": { + "import": "./index.d.mts", + "default": "./index.d.ts" + } + }, + "./package.json": "./package.json" + } +} \ No newline at end of file -- cgit v1.2.3