seyfert 1.4.0 → 2.0.0

package/lib/client/client.d.ts

@@ -1,21 +1,25 @@
-import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from 'discord-api-types/v10';
-import type { Command, CommandContext, Message, SubCommand } from '..';
-import { type DeepPartial, type If } from '../common';
+import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from '../types';
+import type { CommandContext, Message } from '..';
+import { type Awaitable, type DeepPartial, type If } from '../common';
 import { EventHandler } from '../events';
-import { ClientUser } from '../structures';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
+import { Collectors } from './collectors';
+import { type ClientUserStructure, type MessageStructure } from './transformers';
 export declare class Client<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     gateway: ShardManager;
-    events?: EventHandler | undefined;
-    me: If<Ready, ClientUser>;
-    options: ClientOptions;
+    me: If<Ready, ClientUserStructure>;
+    options: Omit<ClientOptions, 'commands'> & {
+        commands: NonNullable<ClientOptions['commands']>;
+    };
     memberUpdateHandler: MemberUpdateHandler;
     presenceUpdateHandler: PresenceUpdateHandler;
+    collectors: Collectors;
+    events?: EventHandler | undefined;
     constructor(options?: ClientOptions);
     setServices({ gateway, ...rest }: ServicesOptions & {
         gateway?: ShardManager;
@@ -43,10 +47,9 @@ export interface ClientOptions extends BaseClientOptions {
         compress?: ShardManagerOptions['compress'];
     };
     commands?: BaseClientOptions['commands'] & {
-        prefix?: (message: Message) => Promise<string[]> | string[];
+        prefix?: (message: MessageStructure) => Awaitable<string[]>;
         deferReplyResponse?: (ctx: CommandContext) => Parameters<Message['write']>[0];
         reply?: (ctx: CommandContext) => boolean;
-        argsParser?: (content: string, command: SubCommand | Command, message: Message) => Record<string, string>;
     };
     handlePayload?: ShardManagerOptions['handlePayload'];
 }

package/lib/client/client.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
-const v10_1 = require("discord-api-types/v10");
+const types_1 = require("../types");
 const common_1 = require("../common");
 const events_1 = require("../events");
-const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
 const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-const onmessagecreate_1 = require("./onmessagecreate");
+const collectors_1 = require("./collectors");
+const transformers_1 = require("./transformers");
 let parentPort;
 class Client extends base_1.BaseClient {
     __handleGuilds = new Set();
     gateway;
-    events = new events_1.EventHandler(this.logger);
     me;
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    collectors = new collectors_1.Collectors();
+    events = new events_1.EventHandler(this);
     constructor(options) {
         super(options);
     }
@@ -38,10 +38,7 @@ class Client extends base_1.BaseClient {
                 this.events = undefined;
             }
             else if (typeof rest.handlers.events === 'function') {
-                this.events = new events_1.EventHandler(this.logger);
-                this.events.setHandlers({
-                    callback: rest.handlers.events,
-                });
+                this.events = new events_1.EventHandler(this);
             }
             else {
                 this.events = rest.handlers.events;
@@ -61,10 +58,7 @@ class Client extends base_1.BaseClient {
         if (worker_threads?.parentPort) {
             parentPort = worker_threads.parentPort;
         }
-        if (!worker_threads?.workerData?.__USING_WATCHER__) {
-            await this.gateway.spawnShards();
-        }
-        else {
+        if (worker_threads?.workerData?.__USING_WATCHER__) {
             parentPort?.on('message', (data) => {
                 switch (data.type) {
                     case 'PAYLOAD':
@@ -76,6 +70,9 @@ class Client extends base_1.BaseClient {
                 }
             });
         }
+        else {
+            await this.gateway.spawnShards();
+        }
     }
     async start(options = {}, execute = true) {
         await super.start(options);
@@ -98,7 +95,10 @@ class Client extends base_1.BaseClient {
                 shardStart: this.options?.shards?.start,
                 shardEnd: this.options?.shards?.end ?? this.options?.shards?.total,
                 totalShards: this.options?.shards?.total ?? this.options?.shards?.end,
-                properties: { ...this.options?.gateway?.properties, ...websocket_1.properties },
+                properties: {
+                    ...websocket_1.properties,
+                    ...this.options?.gateway?.properties,
+                },
                 compress: this.options?.gateway?.compress,
             });
         }
@@ -111,7 +111,10 @@ class Client extends base_1.BaseClient {
         }
     }
     async onPacket(shardId, packet) {
-        await this.events?.runEvent('RAW', this, packet, shardId);
+        Promise.allSettled([
+            this.events?.runEvent('RAW', this, packet, shardId, false),
+            this.collectors.run('RAW', packet, this),
+        ]); //ignore promise
         switch (packet.t) {
             //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
@@ -119,72 +122,63 @@ class Client extends base_1.BaseClient {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
             case 'PRESENCE_UPDATE':
                 if (!this.presenceUpdateHandler.check(packet.d)) {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
-            case 'MESSAGE_UPDATE':
-            case 'MESSAGE_DELETE_BULK':
-            case 'MESSAGE_DELETE':
             case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE':
-            case 'GUILD_EMOJIS_UPDATE':
-            case 'GUILD_UPDATE':
-            case 'GUILD_ROLE_UPDATE':
-            case 'GUILD_ROLE_DELETE':
-            case 'THREAD_UPDATE':
-            case 'USER_UPDATE':
-            case 'VOICE_STATE_UPDATE':
-            case 'STAGE_INSTANCE_UPDATE':
-            case 'GUILD_STICKERS_UPDATE':
+            case 'GUILD_CREATE': {
+                if (this.__handleGuilds?.has(packet.d.id)) {
+                    this.__handleGuilds?.delete(packet.d.id);
+                    if (!this.__handleGuilds?.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
+                        delete this.__handleGuilds;
+                        await this.cache.onPacket?.(packet);
+                        return this.events?.runEvent('BOT_READY', this, this.me, -1);
+                    }
+                    if (!this.__handleGuilds?.size)
+                        delete this.__handleGuilds;
+                    return this.cache.onPacket?.(packet);
+                }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
+            }
             //rest of the events
             default: {
-                await this.cache.onPacket(packet);
                 switch (packet.t) {
                     case 'INTERACTION_CREATE':
-                        await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.interaction(packet.d, shardId);
                         break;
                     case 'MESSAGE_CREATE':
-                        await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
+                        await this.events?.execute(packet.t, packet, this, shardId);
+                        await this.handleCommand.message(packet.d, shardId);
                         break;
                     case 'READY':
+                        if (!this.__handleGuilds)
+                            this.__handleGuilds = new Set();
                         for (const g of packet.d.guilds) {
                             this.__handleGuilds?.add(g.id);
                         }
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
-                        this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                        if (!this.__handleGuilds?.size ||
-                            !((this.gateway.options.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
+                        this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
+                        if (!(this.__handleGuilds?.size &&
+                            (this.gateway.options.intents & types_1.GatewayIntentBits.Guilds) === types_1.GatewayIntentBits.Guilds)) {
                             if ([...this.gateway.values()].every(shard => shard.data.session_id)) {
                                 await this.events?.runEvent('BOT_READY', this, this.me, -1);
                             }
                             delete this.__handleGuilds;
                         }
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
+                        await this.events?.execute(packet.t, packet, this, shardId);
                         break;
-                    case 'GUILD_CREATE': {
-                        if (this.__handleGuilds?.has(packet.d.id)) {
-                            this.__handleGuilds.delete(packet.d.id);
-                            if (!this.__handleGuilds.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
-                                await this.events?.runEvent('BOT_READY', this, this.me, -1);
-                            }
-                            if (!this.__handleGuilds.size)
-                                delete this.__handleGuilds;
-                            return;
-                        }
+                    default:
+                        await this.events?.execute(packet.t, packet, this, shardId);
                         break;
-                    }
                 }
-                await this.events?.execute(packet.t, packet, this, shardId);
                 break;
             }
         }

package/lib/client/collectors.d.ts

@@ -0,0 +1,36 @@
+import type { Awaitable, CamelCase } from '../common';
+import type { CallbackEventHandler, CustomEventsKeys, GatewayEvents } from '../events';
+export type AllClientEvents = CustomEventsKeys | GatewayEvents;
+export type ParseClientEventName<T extends AllClientEvents> = T extends CustomEventsKeys ? T : CamelCase<T>;
+export type CollectorRunPameters<T extends AllClientEvents> = Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>;
+type RunData<T extends AllClientEvents> = {
+    options: {
+        event: T;
+        idle?: number;
+        timeout?: number;
+        onStop?: (reason: string) => unknown;
+        onStopError?: (reason: string, error: unknown) => unknown;
+        filter: (arg: CollectorRunPameters<T>) => Awaitable<boolean>;
+        run: (arg: CollectorRunPameters<T>, stop: (reason?: string) => void) => unknown;
+        onRunError?: (arg: CollectorRunPameters<T>, error: unknown, stop: (reason?: string) => void) => unknown;
+    };
+    idle?: NodeJS.Timeout;
+    timeout?: NodeJS.Timeout;
+    nonce: string;
+};
+export declare class Collectors {
+    readonly values: Map<AllClientEvents, RunData<any>[]>;
+    private generateRandomUUID;
+    create<T extends AllClientEvents>(options: RunData<T>['options']): {
+        event: T;
+        idle?: number;
+        timeout?: number;
+        onStop?: (reason: string) => unknown;
+        onStopError?: (reason: string, error: unknown) => unknown;
+        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string) => void) => unknown;
+        onRunError?: ((arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string) => void) => unknown) | undefined;
+    };
+    private delete;
+}
+export {};

package/lib/client/collectors.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collectors = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_console_1 = require("node:console");
+const RawEvents = __importStar(require("../events/hooks"));
+class Collectors {
+    values = new Map();
+    generateRandomUUID(name) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return '*';
+        let nonce = (0, node_crypto_1.randomUUID)();
+        while (collectors.find(x => x.nonce === nonce)) {
+            nonce = (0, node_crypto_1.randomUUID)();
+        }
+        return nonce;
+    }
+    create(options) {
+        const nonce = this.generateRandomUUID(options.event);
+        if (!this.values.has(options.event)) {
+            this.values.set(options.event, []);
+        }
+        this.values.get(options.event).push({
+            options: {
+                ...options,
+                name: options.event,
+            },
+            idle: options.idle && options.idle > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'idle');
+                }, options.idle)
+                : undefined,
+            timeout: options.timeout && options.timeout > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'timeout');
+                }, options.timeout)
+                : undefined,
+            nonce,
+        });
+        return options;
+    }
+    async delete(name, nonce, reason = 'unknown') {
+        const collectors = this.values.get(name);
+        if (!collectors?.length) {
+            if (collectors)
+                this.values.delete(name);
+            return;
+        }
+        const index = collectors.findIndex(x => x.nonce === nonce);
+        if (index === -1)
+            return;
+        const collector = collectors[index];
+        clearTimeout(collector.idle);
+        clearTimeout(collector.timeout);
+        collectors.splice(index, 1);
+        try {
+            await collector.options.onStop?.(reason);
+        }
+        catch (e) {
+            await collector.options.onStopError?.(reason, node_console_1.error);
+        }
+    }
+    /**@internal */
+    async run(name, raw, client) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return;
+        const data = (await RawEvents[name]?.(client, raw)) ?? raw;
+        for (const i of collectors) {
+            if (await i.options.filter(data)) {
+                i.idle?.refresh();
+                const stop = (reason = 'unknown') => {
+                    return this.delete(i.options.event, i.nonce, reason);
+                };
+                try {
+                    await i.options.run(data, stop);
+                }
+                catch (e) {
+                    await i.options.onRunError?.(data, e, stop);
+                }
+                break;
+            }
+        }
+    }
+}
+exports.Collectors = Collectors;

package/lib/client/httpclient.d.ts

@@ -1,19 +1,14 @@
-/// <reference types="node" />
-import { type APIInteraction } from 'discord-api-types/v10';
-import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
-import { type DeepPartial } from '../common';
+import type { APIInteractionResponse, APIInteraction } from '../types';
+import type { DeepPartial } from '../common';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 export declare class HttpClient extends BaseClient {
-    app?: ReturnType<typeof import('uWebSockets.js').App>;
-    publicKey: string;
-    publicKeyHex: Buffer;
     constructor(options?: BaseClientOptions);
-    protected static readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
-    protected execute(options: DeepPartial<StartOptions['httpConnection']>): Promise<void>;
     start(options?: DeepPartial<Omit<StartOptions, 'connection' | 'eventsDir'>>): Promise<void>;
-    protected verifySignatureGenericRequest(req: Request): Promise<APIInteraction | undefined>;
-    protected verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
-    fetch(req: Request): Promise<Response>;
-    protected onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
+    onPacket(rawBody: APIInteraction): Promise<{
+        headers: {
+            'Content-Type'?: string;
+        };
+        response: APIInteractionResponse | FormData;
+    }>;
 }

package/lib/client/httpclient.js

@@ -1,237 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
-const v10_1 = require("discord-api-types/v10");
-const magic_bytes_js_1 = require("magic-bytes.js");
-const api_1 = require("../api");
 const utils_1 = require("../api/utils/utils");
-const common_1 = require("../common");
 const base_1 = require("./base");
-const oninteractioncreate_1 = require("./oninteractioncreate");
-let UWS;
-let nacl;
-try {
-    UWS = require('uWebSockets.js');
-}
-catch {
-    // easter egg #1
-}
-try {
-    nacl = require('tweetnacl');
-}
-catch {
-    // I always cum
-}
 class HttpClient extends base_1.BaseClient {
-    app;
-    publicKey;
-    publicKeyHex;
     constructor(options) {
         super(options);
-        // if (!UWS) {
-        // 	throw new Error('No uws installed.');
-        // }
-        if (!nacl) {
-            throw new Error('No tweetnacl installed.');
-        }
     }
-    static readJson(res) {
-        return new Promise((cb, err) => {
-            let buffer;
-            res.onData((ab, isLast) => {
-                const chunk = Buffer.from(ab);
-                if (isLast) {
-                    let json;
-                    try {
-                        json = JSON.parse(buffer ? Buffer.concat([buffer, chunk]).toString() : chunk.toString());
+    async start(options = {}) {
+        await super.start(options);
+        return this.execute(options.httpConnection ?? {});
+    }
+    async onPacket(rawBody) {
+        return new Promise(async (r) => {
+            await this.handleCommand.interaction(rawBody, -1, async ({ body, files }) => {
+                let response;
+                const headers = {};
+                if (files) {
+                    response = new FormData();
+                    for (const [index, file] of files.entries()) {
+                        const fileKey = file.key ?? `files[${index}]`;
+                        if ((0, utils_1.isBufferLike)(file.data)) {
+                            response.append(fileKey, new Blob([file.data], { type: file.contentType }), file.name);
+                        }
+                        else {
+                            response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                        }
                     }
-                    catch (e) {
-                        res.close();
-                        return;
+                    if (body) {
+                        response.append('payload_json', JSON.stringify(body));
                     }
-                    cb(json);
                 }
                 else {
-                    buffer = Buffer.concat(buffer ? [buffer, chunk] : [chunk]);
+                    response = body ?? {};
+                    headers['Content-Type'] = 'application/json';
                 }
+                return r({
+                    headers,
+                    response,
+                });
             });
-            res.onAborted(err);
         });
     }
-    async execute(options) {
-        await super.execute();
-        const { publicKey: publicKeyRC, port: portRC, applicationId: applicationIdRC, } = await this.getRC();
-        const publicKey = options.publicKey ?? publicKeyRC;
-        const port = options.port ?? portRC;
-        if (!publicKey) {
-            throw new Error('Expected a publicKey, check your config file');
-        }
-        if (!port) {
-            throw new Error('Expected a port, check your config file');
-        }
-        if (applicationIdRC) {
-            this.applicationId = applicationIdRC;
-        }
-        this.publicKey = publicKey;
-        this.publicKeyHex = Buffer.from(this.publicKey, 'hex');
-        if (UWS && options.useUWS) {
-            this.app = UWS.App();
-            this.app.post('/interactions', (res, req) => {
-                return this.onPacket(res, req);
-            });
-            this.app.listen(port, () => {
-                this.logger.info(`Listening to <url>:${port}/interactions`);
-            });
-        }
-        else {
-            if (options.useUWS)
-                return this.logger.warn('No uWebSockets installed.');
-            this.logger.info('Use your preferred http server and invoke <HttpClient>.fetch(<Request>) to get started');
-        }
-    }
-    async start(options = {}) {
-        await super.start(options);
-        return this.execute((0, common_1.MergeOptions)({ useUWS: true }, options.httpConnection));
-    }
-    async verifySignatureGenericRequest(req) {
-        const timestamp = req.headers.get('x-signature-timestamp');
-        const ed25519 = req.headers.get('x-signature-ed25519') ?? '';
-        const body = (await req.json());
-        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
-            return body;
-        }
-        return;
-    }
-    // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
-    async verifySignature(res, req) {
-        const timestamp = req.getHeader('x-signature-timestamp');
-        const ed25519 = req.getHeader('x-signature-ed25519');
-        const body = await HttpClient.readJson(res);
-        if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
-            return body;
-        }
-        return;
-    }
-    async fetch(req) {
-        const rawBody = await this.verifySignatureGenericRequest(req);
-        if (!rawBody) {
-            this.debugger?.debug('Invalid request/No info, returning 418 status.');
-            // I'm a teapot
-            return new Response('', { status: 418 });
-        }
-        switch (rawBody.type) {
-            case v10_1.InteractionType.Ping:
-                this.debugger?.debug('Ping interaction received, responding.');
-                return Response.json({ type: v10_1.InteractionResponseType.Pong }, {
-                    headers: {
-                        'Content-Type': 'application/json',
-                    },
-                });
-            default:
-                return new Promise(r => {
-                    if ((0, common_1.isCloudfareWorker)())
-                        return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1)
-                            .then(() => r(new Response()))
-                            .catch(() => r(new Response()));
-                    return (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
-                        let response;
-                        const headers = {};
-                        if (files) {
-                            response = new FormData();
-                            for (const [index, file] of files.entries()) {
-                                const fileKey = file.key ?? `files[${index}]`;
-                                if ((0, utils_1.isBufferLike)(file.data)) {
-                                    let contentType = file.contentType;
-                                    if (!contentType) {
-                                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
-                                        if (parsedType) {
-                                            contentType =
-                                                api_1.OverwrittenMimeTypes[parsedType.mime] ??
-                                                    parsedType.mime ??
-                                                    'application/octet-stream';
-                                        }
-                                    }
-                                    response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
-                                }
-                                else {
-                                    response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
-                                }
-                            }
-                            if (body) {
-                                response.append('payload_json', JSON.stringify(body));
-                            }
-                        }
-                        else {
-                            response = body ?? {};
-                            headers['Content-Type'] = 'application/json';
-                        }
-                        r(response instanceof FormData
-                            ? new Response(response, { headers })
-                            : Response.json(response, {
-                                headers,
-                            }));
-                    });
-                });
-        }
-    }
-    async onPacket(res, req) {
-        const rawBody = await this.verifySignature(res, req);
-        if (!rawBody) {
-            this.debugger?.debug('Invalid request/No info, returning 418 status.');
-            // I'm a teapot
-            res.writeStatus('418').end();
-        }
-        else {
-            switch (rawBody.type) {
-                case v10_1.InteractionType.Ping:
-                    this.debugger?.debug('Ping interaction received, responding.');
-                    res
-                        .writeHeader('Content-Type', 'application/json')
-                        .end(JSON.stringify({ type: v10_1.InteractionResponseType.Pong }));
-                    break;
-                default:
-                    await (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
-                        res.cork(() => {
-                            let response;
-                            const headers = {};
-                            if (files) {
-                                response = new FormData();
-                                for (const [index, file] of files.entries()) {
-                                    const fileKey = file.key ?? `files[${index}]`;
-                                    if ((0, utils_1.isBufferLike)(file.data)) {
-                                        let contentType = file.contentType;
-                                        if (!contentType) {
-                                            const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
-                                            if (parsedType) {
-                                                contentType =
-                                                    api_1.OverwrittenMimeTypes[parsedType.mime] ??
-                                                        parsedType.mime ??
-                                                        'application/octet-stream';
-                                            }
-                                        }
-                                        response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
-                                    }
-                                    else {
-                                        response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
-                                    }
-                                }
-                                if (body) {
-                                    response.append('payload_json', JSON.stringify(body));
-                                }
-                            }
-                            else {
-                                response = body ?? {};
-                                headers['Content-Type'] = 'application/json';
-                            }
-                            for (const i in headers) {
-                                res.writeHeader(i, headers[i]);
-                            }
-                            return res.end(JSON.stringify(response));
-                        });
-                    });
-                    break;
-            }
-        }
-    }
 }
 exports.HttpClient = HttpClient;