seyfert 0.1.0

package/lib/websocket/discord/memberUpdate.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberUpdateHandler = void 0;
+class MemberUpdateHandler {
+    guildMemberUpdate = new Map();
+    check(member) {
+        if (!this.guildMemberUpdate.has(member.user.id)) {
+            this.setMember(member);
+            return true;
+        }
+        const data = this.guildMemberUpdate.get(member.user.id);
+        if (this.usersEqual(data.member.user, member.user)) {
+            return this.membersEquals(data.member, member);
+        }
+        clearTimeout(data.timeout);
+        this.setMember(member);
+        return true;
+    }
+    setMember(member) {
+        this.guildMemberUpdate.set(member.user.id, {
+            member,
+            timeout: setTimeout(() => {
+                this.guildMemberUpdate.delete(member.user.id);
+            }, 1.5e3),
+        });
+    }
+    membersEquals(old, member) {
+        return (old.joined_at === member.joined_at &&
+            old.nick === member.nick &&
+            old.avatar === member.avatar &&
+            old.pending === member.pending &&
+            old.communication_disabled_until === member.communication_disabled_until &&
+            old.flags === member.flags &&
+            (old.roles === member.roles ||
+                (old.roles.length === member.roles.length && old.roles.every((role, i) => role === member.roles[i]))));
+    }
+    usersEqual(old, user) {
+        return (old.username === user.username &&
+            old.discriminator === user.discriminator &&
+            old.global_name === user.global_name &&
+            old.avatar === user.avatar &&
+            old.public_flags === user.public_flags &&
+            old.banner === user.banner &&
+            old.accent_color === user.accent_color);
+    }
+}
+exports.MemberUpdateHandler = MemberUpdateHandler;

package/lib/websocket/discord/shard.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import type WS from 'ws';
+import { type CloseEvent } from 'ws';
+import type { GatewayReceivePayload, GatewaySendPayload, Logger } from '../../common';
+import { DynamicBucket, PriorityQueue } from '../structures';
+import { ConnectTimeout } from '../structures/timeout';
+import { BaseSocket } from './basesocket';
+import type { ShardData, ShardOptions } from './shared';
+export interface ShardHeart {
+    interval: number;
+    nodeInterval?: NodeJS.Timeout;
+    lastAck?: number;
+    lastBeat?: number;
+    ack: boolean;
+}
+export declare class Shard {
+    id: number;
+    options: ShardOptions;
+    debugger?: Logger;
+    data: Partial<ShardData> | ShardData;
+    websocket: BaseSocket | null;
+    connectTimeout: ConnectTimeout;
+    heart: ShardHeart;
+    bucket: DynamicBucket;
+    offlineSendQueue: PriorityQueue<(_?: unknown) => void>;
+    constructor(id: number, options: ShardOptions);
+    get latency(): number;
+    get isOpen(): boolean;
+    get gatewayURL(): string;
+    get resumeGatewayURL(): string | undefined;
+    get currentGatewayURL(): string;
+    connect(): Promise<void>;
+    send<T extends GatewaySendPayload = GatewaySendPayload>(priority: number, message: T): Promise<void>;
+    identify(): Promise<void>;
+    get resumable(): boolean;
+    resume(): Promise<void>;
+    heartbeat(requested: boolean): Promise<void>;
+    disconnect(): Promise<void>;
+    reconnect(): Promise<void>;
+    onpacket(packet: GatewayReceivePayload): Promise<void>;
+    protected handleClosed(close: CloseEvent): Promise<void>;
+    close(code: number, reason: string): Promise<void>;
+    protected handleMessage({ data }: WS.MessageEvent): Promise<void>;
+    checkOffline(priority: number): Promise<unknown>;
+    calculateSafeRequests(): number;
+}

package/lib/websocket/discord/shard.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shard = void 0;
+const node_zlib_1 = require("node:zlib");
+const ws_1 = require("ws");
+const common_1 = require("../../common");
+const constants_1 = require("../constants");
+const structures_1 = require("../structures");
+const timeout_1 = require("../structures/timeout");
+const basesocket_1 = require("./basesocket");
+const shared_1 = require("./shared");
+class Shard {
+    id;
+    options;
+    debugger;
+    data = {
+        resumeSeq: null,
+    };
+    websocket = null;
+    connectTimeout = new timeout_1.ConnectTimeout();
+    heart = {
+        interval: 30e3,
+        ack: true,
+    };
+    bucket;
+    offlineSendQueue = new structures_1.PriorityQueue();
+    constructor(id, options) {
+        this.id = id;
+        this.options = options;
+        this.options.ratelimitOptions ??= {
+            rateLimitResetInterval: 60_000,
+            maxRequestsPerRateLimitTick: 120,
+        };
+        if (options.debugger)
+            this.debugger = options.debugger;
+        const safe = this.calculateSafeRequests();
+        this.bucket = new structures_1.DynamicBucket({
+            limit: safe,
+            refillAmount: safe,
+            refillInterval: 6e4,
+            debugger: this.debugger,
+        });
+    }
+    get latency() {
+        return this.heart.lastAck && this.heart.lastBeat ? this.heart.lastAck - this.heart.lastBeat : Infinity;
+    }
+    get isOpen() {
+        return this.websocket?.readyState === ws_1.WebSocket.OPEN;
+    }
+    get gatewayURL() {
+        return this.options.info.url;
+    }
+    get resumeGatewayURL() {
+        return this.data.resume_gateway_url;
+    }
+    get currentGatewayURL() {
+        const url = new URL(this.resumeGatewayURL ?? this.options.info.url);
+        url.searchParams.set('v', '10');
+        return url.href;
+    }
+    async connect() {
+        await this.connectTimeout.wait();
+        if (this.isOpen) {
+            this.debugger?.debug(`[Shard #${this.id}] attempted to connect while open`);
+            return;
+        }
+        this.debugger?.debug(`[Shard #${this.id}] Connecting to ${this.currentGatewayURL}`);
+        // @ts-expect-error @types/bun cause erros in compile
+        this.websocket = new basesocket_1.BaseSocket(typeof Bun === 'undefined' ? 'ws' : 'bun', this.currentGatewayURL);
+        this.websocket.onmessage = (event) => this.handleMessage(event);
+        this.websocket.onclose = (event) => this.handleClosed(event);
+        this.websocket.onerror = (event) => this.debugger?.error(event);
+        this.websocket.onopen = () => {
+            this.heart.ack = true;
+        };
+    }
+    async send(priority, message) {
+        this.debugger?.info(`[Shard #${this.id}] Sending: ${common_1.GatewayOpcodes[message.op]} ${JSON.stringify(message.d, (_, value) => {
+            if (typeof value === 'string')
+                return value.replace(this.options.token, v => {
+                    const split = v.split('.');
+                    return `${split[0]}.${'*'.repeat(split[1].length)}.${'*'.repeat(split[2].length)}`;
+                });
+            return value;
+        }, 1)}`);
+        await this.checkOffline(priority);
+        await this.bucket.acquire(priority);
+        await this.checkOffline(priority);
+        this.websocket?.send(JSON.stringify(message));
+    }
+    async identify() {
+        await this.send(0, {
+            op: common_1.GatewayOpcodes.Identify,
+            d: {
+                token: `Bot ${this.options.token}`,
+                compress: this.options.compress,
+                properties: constants_1.properties,
+                shard: [this.id, this.options.info.shards],
+                intents: this.options.intents,
+                presence: this.options.presence,
+            },
+        });
+    }
+    get resumable() {
+        return !!(this.data.resume_gateway_url && this.data.session_id && this.data.resumeSeq !== null);
+    }
+    async resume() {
+        await this.send(0, {
+            op: common_1.GatewayOpcodes.Resume,
+            d: {
+                seq: this.data.resumeSeq,
+                session_id: this.data.session_id,
+                token: `Bot ${this.options.token}`,
+            },
+        });
+    }
+    async heartbeat(requested) {
+        this.debugger?.debug(`[Shard #${this.id}] Sending ${requested ? '' : 'un'}requested heartbeat (Ack=${this.heart.ack})`);
+        if (!requested) {
+            if (!this.heart.ack) {
+                await this.close(shared_1.ShardSocketCloseCodes.ZombiedConnection, 'Zombied connection');
+                return;
+            }
+            this.heart.ack = false;
+        }
+        this.heart.lastBeat = Date.now();
+        this.websocket.send(JSON.stringify({
+            op: common_1.GatewayOpcodes.Heartbeat,
+            d: this.data.resumeSeq ?? null,
+        }));
+    }
+    async disconnect() {
+        this.debugger?.info(`[Shard #${this.id}] Disconnecting`);
+        await this.close(shared_1.ShardSocketCloseCodes.Shutdown, 'Shard down request');
+    }
+    async reconnect() {
+        this.debugger?.info(`[Shard #${this.id}] Reconnecting`);
+        await this.disconnect();
+        await this.connect();
+    }
+    async onpacket(packet) {
+        if (packet.s !== null) {
+            this.data.resumeSeq = packet.s;
+        }
+        this.debugger?.debug(`[Shard #${this.id}]`, packet.t ? packet.t : common_1.GatewayOpcodes[packet.op], this.data.resumeSeq);
+        switch (packet.op) {
+            case common_1.GatewayOpcodes.Hello:
+                {
+                    clearInterval(this.heart.nodeInterval);
+                    this.heart.interval = packet.d.heartbeat_interval;
+                    await this.heartbeat(false);
+                    this.heart.nodeInterval = setInterval(() => this.heartbeat(false), this.heart.interval);
+                    if (this.resumable) {
+                        return this.resume();
+                    }
+                    await this.identify();
+                }
+                break;
+            case common_1.GatewayOpcodes.HeartbeatAck:
+                this.heart.ack = true;
+                this.heart.lastAck = Date.now();
+                break;
+            case common_1.GatewayOpcodes.Heartbeat:
+                this.heartbeat(true);
+                break;
+            case common_1.GatewayOpcodes.Reconnect:
+                await this.reconnect();
+                break;
+            case common_1.GatewayOpcodes.InvalidSession:
+                if (packet.d) {
+                    if (!this.resumable) {
+                        return this.debugger?.fatal(`[Shard #${this.id}] This is a completely unexpected error message.`);
+                    }
+                    await this.resume();
+                }
+                else {
+                    this.data.resumeSeq = 0;
+                    this.data.session_id = undefined;
+                    await this.identify();
+                }
+                break;
+            case common_1.GatewayOpcodes.Dispatch:
+                {
+                    switch (packet.t) {
+                        case common_1.GatewayDispatchEvents.Resumed:
+                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.options.handlePayload(this.id, packet);
+                            break;
+                        case common_1.GatewayDispatchEvents.Ready: {
+                            this.data.resume_gateway_url = packet.d.resume_gateway_url;
+                            this.data.session_id = packet.d.session_id;
+                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.options.handlePayload(this.id, packet);
+                            break;
+                        }
+                        default:
+                            this.options.handlePayload(this.id, packet);
+                            break;
+                    }
+                }
+                break;
+        }
+    }
+    async handleClosed(close) {
+        clearInterval(this.heart.nodeInterval);
+        this.debugger?.warn(`[Shard #${this.id}] ${shared_1.ShardSocketCloseCodes[close.code] ?? common_1.GatewayCloseCodes[close.code] ?? close.code} (${close.code})`);
+        switch (close.code) {
+            case shared_1.ShardSocketCloseCodes.Shutdown:
+                break;
+            case 1000:
+            case 1001:
+            case 1006:
+            case shared_1.ShardSocketCloseCodes.ZombiedConnection:
+            case common_1.GatewayCloseCodes.UnknownError:
+            case common_1.GatewayCloseCodes.UnknownOpcode:
+            case common_1.GatewayCloseCodes.DecodeError:
+            case common_1.GatewayCloseCodes.NotAuthenticated:
+            case common_1.GatewayCloseCodes.AlreadyAuthenticated:
+            case common_1.GatewayCloseCodes.InvalidSeq:
+            case common_1.GatewayCloseCodes.RateLimited:
+            case common_1.GatewayCloseCodes.SessionTimedOut:
+                this.debugger?.info(`[Shard #${this.id}] Trying to reconnect`);
+                await this.reconnect();
+                break;
+            case common_1.GatewayCloseCodes.AuthenticationFailed:
+            case common_1.GatewayCloseCodes.DisallowedIntents:
+            case common_1.GatewayCloseCodes.InvalidAPIVersion:
+            case common_1.GatewayCloseCodes.InvalidIntents:
+            case common_1.GatewayCloseCodes.InvalidShard:
+            case common_1.GatewayCloseCodes.ShardingRequired:
+                this.debugger?.fatal(`[Shard #${this.id}] cannot reconnect`);
+                break;
+            default:
+                this.debugger?.warn(`[Shard #${this.id}] Unknown close code, trying to reconnect anyways`);
+                await this.reconnect();
+                break;
+        }
+    }
+    async close(code, reason) {
+        if (this.websocket?.readyState !== ws_1.WebSocket.OPEN) {
+            return this.debugger?.warn(`[Shard #${this.id}] Is not open`);
+        }
+        this.debugger?.warn(`[Shard #${this.id}] Called close`);
+        this.websocket?.close(code, reason);
+    }
+    handleMessage({ data }) {
+        if (data instanceof Buffer) {
+            data = (0, node_zlib_1.inflateSync)(data);
+        }
+        /**
+         * Idk why, but Bun sends this event when websocket connects.
+         * MessageEvent {
+         *  type: "message",
+         *  data: "Already authenticated."
+         * }
+         */
+        if (data.startsWith('{')) {
+            data = JSON.parse(data);
+        }
+        const packet = data;
+        return this.onpacket(packet);
+    }
+    checkOffline(priority) {
+        if (!this.isOpen) {
+            return new Promise(resolve => this.offlineSendQueue.push(resolve, priority));
+        }
+        return Promise.resolve();
+    }
+    calculateSafeRequests() {
+        const safeRequests = this.options.ratelimitOptions.maxRequestsPerRateLimitTick -
+            Math.ceil(this.options.ratelimitOptions.rateLimitResetInterval / this.heart.interval) * 2;
+        if (safeRequests < 0) {
+            return 0;
+        }
+        return safeRequests;
+    }
+}
+exports.Shard = Shard;

package/lib/websocket/discord/sharder.d.ts

@@ -0,0 +1,25 @@
+import { Logger, type GatewaySendPayload, type GatewayUpdatePresence, type GatewayVoiceStateUpdate, type ObjectToLower } from '../../common';
+import { ConnectQueue } from '../structures/timeout';
+import { Shard } from './shard.js';
+import type { ShardManagerOptions } from './shared';
+export declare class ShardManager extends Map<number, Shard> {
+    connectQueue: ConnectQueue;
+    options: ShardManagerOptions;
+    debugger?: Logger;
+    constructor(options: ShardManagerOptions);
+    get remaining(): number;
+    get concurrency(): number;
+    get latency(): number;
+    calculeShardId(guildId: string): number;
+    spawn(shardId: number): Shard;
+    spawnShards(): Promise<void>;
+    spawnBuckets(): Shard[][];
+    forceIdentify(shardId: number): Promise<void>;
+    disconnect(shardId: number): Promise<void> | undefined;
+    disconnectAll(): Promise<unknown>;
+    setShardPresence(shardId: number, payload: GatewayUpdatePresence['d']): void;
+    setPresence(payload: GatewayUpdatePresence['d']): Promise<void> | undefined;
+    joinVoice(guild_id: string, channel_id: string, options: ObjectToLower<Pick<GatewayVoiceStateUpdate['d'], 'self_deaf' | 'self_mute'>>): void;
+    leaveVoice(guild_id: string): void;
+    send<T extends GatewaySendPayload>(shardId: number, payload: T): void;
+}

package/lib/websocket/discord/sharder.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardManager = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../../common");
+const constants_1 = require("../constants");
+const structures_1 = require("../structures");
+const timeout_1 = require("../structures/timeout");
+const shard_js_1 = require("./shard.js");
+class ShardManager extends Map {
+    connectQueue;
+    options;
+    debugger;
+    constructor(options) {
+        super();
+        options.totalShards ??= options.info.shards;
+        this.options = (0, common_1.MergeOptions)(constants_1.ShardManagerDefaults, options);
+        this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
+        if (this.options.debug) {
+            this.debugger = new common_1.Logger({
+                name: '[ShardManager]',
+                logLevel: common_1.LogLevels.Debug,
+            });
+        }
+    }
+    get remaining() {
+        return this.options.info.session_start_limit.remaining;
+    }
+    get concurrency() {
+        return this.options.info.session_start_limit.max_concurrency;
+    }
+    get latency() {
+        let acc = 0;
+        this.forEach(s => (acc += s.latency));
+        return acc / this.size;
+    }
+    calculeShardId(guildId) {
+        return Number((BigInt(guildId) >> 22n) % BigInt(this.options.info.shards ?? 1));
+    }
+    spawn(shardId) {
+        this.debugger?.info(`Spawn shard ${shardId}`);
+        let shard = this.get(shardId);
+        shard ??= new shard_js_1.Shard(shardId, {
+            token: this.options.token,
+            intents: this.options.intents,
+            info: { ...this.options.info, shards: (this.options.shardEnd ?? this.options.totalShards) },
+            handlePayload: this.options.handlePayload,
+            properties: this.options.properties,
+            debugger: this.debugger,
+            compress: false,
+            presence: this.options.presence?.(shardId, -1),
+        });
+        this.set(shardId, shard);
+        return shard;
+    }
+    async spawnShards() {
+        const buckets = this.spawnBuckets();
+        this.debugger?.info('Spawn shards');
+        for (const bucket of buckets) {
+            for (const shard of bucket) {
+                if (!shard) {
+                    break;
+                }
+                this.debugger?.info(`${shard.id} add to connect queue`);
+                this.connectQueue.push(shard.connect.bind(shard));
+            }
+        }
+    }
+    /*
+     * spawns buckets in order
+     * https://discord.com/developers/docs/topics/gateway#sharding-max-concurrency
+     */
+    spawnBuckets() {
+        this.debugger?.info('#0 Preparing buckets');
+        const chunks = structures_1.SequentialBucket.chunk(new Array(this.options.shardStart !== undefined && this.options.shardEnd !== undefined
+            ? this.options.shardEnd - this.options.shardStart
+            : this.options.totalShards), this.concurrency);
+        chunks.forEach((arr, index) => {
+            for (let i = 0; i < arr.length; i++) {
+                const id = i + (index > 0 ? index * this.concurrency : 0) + (this.options.shardStart ?? 0);
+                chunks[index][i] = this.spawn(id);
+            }
+        });
+        this.debugger?.info(`${chunks.length} buckets created`);
+        return chunks;
+    }
+    forceIdentify(shardId) {
+        this.debugger?.info(`Shard #${shardId} force identify`);
+        return this.spawn(shardId).identify();
+    }
+    disconnect(shardId) {
+        this.debugger?.info(`Shard #${shardId} force disconnect`);
+        return this.get(shardId)?.disconnect();
+    }
+    disconnectAll() {
+        this.debugger?.info('Disconnect all shards');
+        return new Promise(resolve => {
+            this.forEach(shard => shard.disconnect());
+            resolve(null);
+        });
+    }
+    setShardPresence(shardId, payload) {
+        this.debugger?.info(`Shard #${shardId} update presence`);
+        return this.send(shardId, {
+            op: common_1.GatewayOpcodes.PresenceUpdate,
+            d: payload,
+        });
+    }
+    setPresence(payload) {
+        return new Promise(resolve => {
+            this.forEach(shard => {
+                this.setShardPresence(shard.id, payload);
+            }, this);
+            resolve();
+        });
+    }
+    joinVoice(guild_id, channel_id, options) {
+        const shardId = this.calculeShardId(guild_id);
+        this.debugger?.info(`Shard #${shardId} join voice ${channel_id} in ${guild_id}`);
+        return this.send(shardId, {
+            op: common_1.GatewayOpcodes.VoiceStateUpdate,
+            d: {
+                guild_id,
+                channel_id,
+                ...(0, common_1.toSnakeCase)(options),
+            },
+        });
+    }
+    leaveVoice(guild_id) {
+        const shardId = this.calculeShardId(guild_id);
+        this.debugger?.info(`Shard #${shardId} leave voice in ${guild_id}`);
+        return this.send(shardId, {
+            op: common_1.GatewayOpcodes.VoiceStateUpdate,
+            d: {
+                guild_id,
+                channel_id: null,
+                self_mute: false,
+                self_deaf: false,
+            },
+        });
+    }
+    send(shardId, payload) {
+        if (node_worker_threads_1.workerData?.__USING_WATCHER__) {
+            return node_worker_threads_1.parentPort?.postMessage({
+                type: 'SEND_TO_SHARD',
+                shardId,
+                payload,
+            });
+        }
+        this.get(shardId)?.send(1, payload);
+    }
+}
+exports.ShardManager = ShardManager;

package/lib/websocket/discord/shared.d.ts

@@ -0,0 +1,99 @@
+import type { APIGatewayBotInfo, GatewayDispatchPayload, GatewayIntentBits, GatewayPresenceUpdateData, Logger } from '../../common';
+import type { IdentifyProperties } from '../constants';
+export interface ShardManagerOptions extends ShardDetails {
+    /** Important data which is used by the manager to connect shards to the gateway. */
+    info: APIGatewayBotInfo;
+    /**
+     * Delay in milliseconds to wait before spawning next shard. OPTIMAL IS ABOVE 5100. YOU DON'T WANT TO HIT THE RATE LIMIT!!!
+     * @default 5300
+     */
+    spawnShardDelay?: number;
+    /**
+     * Total amount of shards your bot uses. Useful for zero-downtime updates or resharding.
+     * @default 1
+     */
+    totalShards?: number;
+    shardStart?: number;
+    shardEnd?: number;
+    /**
+     * The payload handlers for messages on the shard.
+     */
+    handlePayload(shardId: number, packet: GatewayDispatchPayload): unknown;
+    /**
+     * wheter to send debug information to the console
+     */
+    debug?: boolean;
+    /**
+     * Set a presence.
+     */
+    presence?: (shardId: number, workerId: number) => GatewayPresenceUpdateData;
+    compress?: boolean;
+}
+export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload'> {
+    workers?: number;
+    /**
+     * @default 32
+     */
+    shardsPerWorker?: number;
+    path: string;
+    handlePayload(shardId: number, workerId: number, packet: GatewayDispatchPayload): unknown;
+}
+export interface ShardData {
+    /** resume seq to resume connections */
+    resumeSeq: number | null;
+    /**
+     * resume_gateway_url is the url to resume the connection
+     * @link https://discord.com/developers/docs/topics/gateway#ready-event
+     */
+    resume_gateway_url?: string;
+    /**
+     * session_id is the unique session id of the gateway
+     * do not mistake with the seyfert client which is named Client
+     */
+    session_id?: string;
+}
+export interface ShardDetails {
+    /** Bot token which is used to connect to Discord */
+    token: string;
+    /**
+     * The URL of the gateway which should be connected to.
+     * @default "wss://gateway.discord.gg"
+     */
+    url?: string;
+    /**
+     * The gateway version which should be used.
+     * @default 10
+     */
+    version?: number;
+    /**
+     * The calculated intent value of the events which the shard should receive.
+     */
+    intents: GatewayIntentBits | number;
+    /**
+     * Identify properties to use
+     */
+    properties?: IdentifyProperties;
+}
+export interface ShardOptions extends ShardDetails {
+    info: APIGatewayBotInfo;
+    handlePayload(shardId: number, packet: GatewayDispatchPayload): unknown;
+    ratelimitOptions?: {
+        maxRequestsPerRateLimitTick: number;
+        rateLimitResetInterval: number;
+    };
+    debugger?: Logger;
+    compress: boolean;
+    presence?: GatewayPresenceUpdateData;
+}
+export declare enum ShardSocketCloseCodes {
+    Shutdown = 3000,
+    ZombiedConnection = 3010
+}
+export interface WorkerData {
+    intents: number;
+    token: string;
+    path: string;
+    shards: number[];
+    workerId: number;
+    debug: boolean;
+}

package/lib/websocket/discord/shared.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShardSocketCloseCodes = void 0;
+var ShardSocketCloseCodes;
+(function (ShardSocketCloseCodes) {
+    ShardSocketCloseCodes[ShardSocketCloseCodes["Shutdown"] = 3000] = "Shutdown";
+    ShardSocketCloseCodes[ShardSocketCloseCodes["ZombiedConnection"] = 3010] = "ZombiedConnection";
+})(ShardSocketCloseCodes || (exports.ShardSocketCloseCodes = ShardSocketCloseCodes = {}));