elynn-baileys 1.0.1

package/lib/Discord/gateway/ShardManager.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module ShardManager */
+const Shard_1 = __importDefault(require("./Shard"));
+const Dispatcher_1 = __importDefault(require("./Dispatcher"));
+const config_1 = __importDefault(require("./compression/config"));
+const Constants_1 = require("../Constants");
+const Collection_1 = __importDefault(require("../util/Collection"));
+const Errors_1 = require("../util/Errors");
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module */
+// @ts-ignore
+let Erlpack;
+try {
+    Erlpack = require("erlpack");
+}
+catch { }
+/* eslint-enable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module */
+/** A manager for all the client's shards. */
+class ShardManager extends Collection_1.default {
+    _buckets;
+    _connectQueue;
+    _connectTimeout;
+    _gatewayURL;
+    client;
+    connected = false;
+    dispatcher;
+    options;
+    constructor(client, options = {}) {
+        super();
+        Object.defineProperty(this, "client", {
+            value: client,
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+        this._buckets = {};
+        this._connectQueue = [];
+        this._connectTimeout = null;
+        this.options = {
+            autoReconnect: options.autoReconnect ?? true,
+            compress: options.compress ?? false,
+            compressLibrary: options.compressLibrary ?? null,
+            connectionProperties: {
+                browser: options.connectionProperties?.browser ?? "Oceanic",
+                device: options.connectionProperties?.device ?? "Oceanic",
+                os: options.connectionProperties?.os ?? process.platform
+            },
+            concurrency: options.concurrency === "auto" || options.concurrency && options.concurrency < 1 ? -1 : options.concurrency ?? -1,
+            connectionTimeout: options.connectionTimeout ?? 30000,
+            dispatcher: {
+                blacklist: options.dispatcher?.blacklist === undefined ? null : options.dispatcher.blacklist,
+                whitelist: options.dispatcher?.whitelist === undefined ? null : options.dispatcher.whitelist
+            },
+            firstShardID: options.firstShardID && options.firstShardID < 0 ? 0 : options.firstShardID ?? 0,
+            getAllUsers: options.getAllUsers ?? false,
+            override: options.override ?? {
+                appendQuery: true,
+                gatewayURLIsResumeURL: false,
+                timeBetweenShardConnects: 5000
+            },
+            guildCreateTimeout: options.guildCreateTimeout ?? 2000,
+            intents: typeof options.intents === "number" ? options.intents : 0,
+            largeThreshold: options.largeThreshold ?? 250,
+            lastShardID: options.lastShardID ?? -1,
+            lookupDisallowedIntents: options.lookupDisallowedIntents ?? false,
+            maxReconnectAttempts: options.maxReconnectAttempts ?? Infinity,
+            maxResumeAttempts: options.maxResumeAttempts ?? 10,
+            maxShards: options.maxShards === "auto" || options.maxShards && options.maxShards < 1 ? -1 : options.maxShards ?? -1,
+            presence: {
+                activities: options.presence?.activities ?? [],
+                afk: options.presence?.afk ?? false,
+                status: options.presence?.status ?? "online"
+            },
+            reconnectDelay: options.reconnectDelay ?? ((lastDelay, attempts) => Math.pow(attempts + 1, 0.7) * 20000),
+            removeDisallowedIntents: options.removeDisallowedIntents ?? false,
+            seedVoiceConnections: options.seedVoiceConnections ?? false,
+            shardIDs: options.shardIDs ?? [],
+            ws: options.ws ?? {}
+        };
+        if (this.options.compress) {
+            const types = Object.keys(config_1.default);
+            if (!types.includes(this.options.compress)) {
+                throw new Error(`Invalid compress type: ${this.options.compress}`);
+            }
+            if (this.options.compressLibrary) {
+                const config = config_1.default[this.options.compress].find(cnf => cnf.name === this.options.compressLibrary);
+                if (!config) {
+                    throw new Error(`Invalid library "${this.options.compressLibrary}" for ${this.options.compress}`);
+                }
+                if (!config.check(client)) {
+                    throw config.getError();
+                }
+            }
+            else {
+                const available = config_1.default[this.options.compress] ?? [];
+                const usable = available.find(av => av.check(client));
+                if (!usable) {
+                    throw new Errors_1.DependencyError(`Unable to find a usable ${this.options.compress} compressor`);
+                }
+                this.options.compressLibrary = usable.name;
+            }
+        }
+        this.options.override.appendQuery ??= (this.options.override.getBot === undefined && this.options.override.url === undefined);
+        this.options.override.gatewayURLIsResumeURL ??= (this.options.override.getBot !== undefined || this.options.override.url !== undefined);
+        this.options.override.timeBetweenShardConnects ??= 5000;
+        if (this.options.lastShardID === -1 && this.options.maxShards !== -1) {
+            this.options.lastShardID = this.options.maxShards - 1;
+        }
+        if (!Array.isArray(this.options.shardIDs)) {
+            this.options.shardIDs = [];
+        }
+        if (Object.hasOwn(options, "intents")) {
+            if (Array.isArray(options.intents)) {
+                let bitmask = 0;
+                for (const intent of options.intents) {
+                    if (typeof intent === "number") {
+                        bitmask |= intent;
+                    }
+                    else if (Constants_1.Intents[intent]) {
+                        bitmask |= Constants_1.Intents[intent];
+                    }
+                    else {
+                        if (intent === "ALL") {
+                            bitmask = Constants_1.AllIntents;
+                            break;
+                        }
+                        else if (intent === "ALL_NON_PRIVILEGED") {
+                            bitmask = Constants_1.AllNonPrivilegedIntents;
+                            continue;
+                        }
+                        client.emit("warn", `Unknown intent: ${intent}`);
+                    }
+                }
+                this.options.intents = bitmask;
+            }
+        }
+        else {
+            this.options.intents = Constants_1.AllNonPrivilegedIntents;
+        }
+        if (this.options.getAllUsers && !(this.options.intents & Constants_1.Intents.GUILD_MEMBERS)) {
+            throw new TypeError("Guild members cannot be requested without the GUILD_MEMBERS intent");
+        }
+        Object.defineProperty(this, "dispatcher", {
+            value: new Dispatcher_1.default(this),
+            writable: false,
+            enumerable: false,
+            configurable: false
+        });
+    }
+    _connect(shard) {
+        this._connectQueue.push(shard);
+        this.tryConnect();
+    }
+    _forGuild(guild) {
+        if (this.options.maxShards === -1) {
+            return undefined;
+        }
+        return this.get((this.client.guildShardMap.get(guild) ?? Number((BigInt(guild) >> 22n) % BigInt(this.options.maxShards))));
+    }
+    async _gatewayURLForShard(shard) {
+        if (this.options.override.url !== undefined) {
+            return this.options.override.url(shard, this.options.shardIDs.length);
+        }
+        if (this._gatewayURL) {
+            return this._gatewayURL;
+        }
+        // how did we manage to get all the way to connecting without gatewayURL being set?
+        return (this._gatewayURL = (await (this.options.override.getBot?.() ?? this.client.rest.getBotGateway())).url);
+    }
+    _ready(id) {
+        const mod = id % this.options.concurrency;
+        const rateLimitKey = isNaN(mod) ? 0 : mod;
+        this._buckets[rateLimitKey] = Date.now();
+        this.tryConnect();
+    }
+    _resetConnectQueue() {
+        this._connectQueue = [];
+    }
+    async connect() {
+        if (this.connected) {
+            throw new Error("Already connected.");
+        }
+        let url, data;
+        const overrideURL = (this.options.override.getBot || this.options.override.url) !== undefined;
+        try {
+            if (this.options.maxShards === -1 || this.options.concurrency === -1) {
+                data = await (this.options.override.getBot?.() ?? this.client.rest.getBotGateway());
+                url = data.url;
+            }
+            else {
+                url = overrideURL ? null : (await this.client.rest.getGateway()).url;
+            }
+        }
+        catch (err) {
+            throw new TypeError("Failed to get gateway information.", { cause: err });
+        }
+        if (url && this.options.override.appendQuery) {
+            if (url.includes("?")) {
+                url = url.slice(0, url.indexOf("?"));
+            }
+            if (!url.endsWith("/")) {
+                url += "/";
+            }
+        }
+        /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+        if (this.options.removeDisallowedIntents && Constants_1.PrivilegedIntentMapping.some(([intent]) => (this.options.intents & intent) === intent)) {
+            const { flags } = await this.client.rest.applications.getCurrent();
+            const check = (intent, allowed) => {
+                if ((this.options.intents & intent) === intent && !allowed.some(flag => (flags & flag) === flag)) {
+                    this.client.emit("warn", `removeDisallowedIntents is enabled, and ${Constants_1.Intents[intent]} was included but not found to be allowed. It has been removed.`);
+                    this.options.intents &= ~intent;
+                }
+            };
+            for (const [intent, allowed] of Constants_1.PrivilegedIntentMapping) {
+                check(intent, allowed);
+            }
+        }
+        /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison */
+        if (url && this.options.override.appendQuery) {
+            url += `?v=${Constants_1.GATEWAY_VERSION}&encoding=${Erlpack ? "etf" : "json"}`;
+            if (this.options.compress) {
+                const type = this.options.compress === "zstd-stream" ? "zstd-stream" : "zlib-stream";
+                url += `&compress=${type}`;
+            }
+            this._gatewayURL = url;
+        }
+        if (this.options.maxShards === -1) {
+            if (!data || !data.shards) {
+                throw new TypeError("AutoSharding failed, missing required information from Discord.");
+            }
+            this.options.maxShards = data.shards;
+            if (this.options.lastShardID === -1) {
+                this.options.lastShardID = data.shards - 1;
+            }
+        }
+        if (this.options.concurrency === -1) {
+            if (!data) {
+                throw new TypeError("AutoConcurrency failed, missing required information from Discord.");
+            }
+            this.options.concurrency = data.sessionStartLimit.maxConcurrency;
+        }
+        if (this.options.shardIDs.length === 0 && this.options.firstShardID !== undefined && this.options.lastShardID !== undefined) {
+            for (let i = this.options.firstShardID; i <= this.options.lastShardID; i++) {
+                this.options.shardIDs.push(i);
+            }
+        }
+        this.connected = true;
+        for (const id of this.options.shardIDs) {
+            this.spawn(id);
+        }
+    }
+    /**
+     * Disconnect all shards.
+     * @param reconnect If shards should be reconnected. Defaults to {@link Types/Gateway~GatewayOptions#autoReconnect | GatewayOptions#autoReconnect}
+     */
+    disconnect(reconnect = this.options.autoReconnect) {
+        if (!reconnect) {
+            this.connected = false;
+        }
+        this.client.ready = false;
+        for (const [, shard] of this)
+            shard.disconnect(reconnect);
+        this.client.time.reset();
+        this._resetConnectQueue();
+    }
+    spawn(id) {
+        let shard = this.get(id);
+        if (!shard) {
+            shard = new Shard_1.default(id, this);
+            this.set(id, shard);
+            shard
+                .on("ready", () => {
+                this.client.time.set("ready", Date.now());
+                this.client.emit("shardReady", id);
+                if (this.client.ready) {
+                    return;
+                }
+                for (const other of this.values()) {
+                    if (!other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = true;
+                this.client.emit("ready");
+            })
+                .on("resume", () => {
+                this.client.time.set("resume", Date.now());
+                this.client.emit("shardResume", id);
+                if (this.client.ready) {
+                    return;
+                }
+                for (const other of this.values()) {
+                    if (!other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = true;
+                this.client.emit("ready");
+            })
+                .on("disconnect", error => {
+                this.client.time.set("disconnect", Date.now());
+                this.client.emit("shardDisconnect", error, id);
+                for (const other of this.values()) {
+                    if (other.ready) {
+                        return;
+                    }
+                }
+                this.client.ready = false;
+                this.client.emit("disconnect");
+            })
+                .on("preReady", () => {
+                this.client.time.set("preReady", Date.now());
+                this.client.emit("shardPreReady", id);
+            });
+        }
+        if (shard.status === "disconnected") {
+            this._connect(shard);
+        }
+    }
+    tryConnect() {
+        if (this._connectQueue.length === 0) {
+            return;
+        }
+        for (const shard of this._connectQueue) {
+            const mod = shard.id % this.options.concurrency;
+            const rateLimitKey = isNaN(mod) ? 0 : mod;
+            const lastConnect = this._buckets[rateLimitKey] ?? 0;
+            if (!shard.sessionID && Date.now() - lastConnect < this.options.override.timeBetweenShardConnects) {
+                continue;
+            }
+            if (this.some(s => s.connecting && ((s.id % this.options.concurrency) || 0) === rateLimitKey)) {
+                continue;
+            }
+            this.client.time.set("connect", Date.now());
+            void shard.connect();
+            this._buckets[rateLimitKey] = Date.now();
+            this._connectQueue.splice(this._connectQueue.findIndex(s => s.id === shard.id), 1);
+        }
+        if (!this._connectTimeout && this._connectQueue.length !== 0) {
+            this._connectTimeout = setTimeout(() => {
+                this._connectTimeout = null;
+                this.tryConnect();
+            }, 500);
+        }
+    }
+}
+exports.default = ShardManager;

package/lib/Discord/gateway/compression/base.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Compressor {
+    shard;
+    constructor(shard) {
+        Object.defineProperty(this, "shard", {
+            value: shard,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+}
+exports.default = Compressor;

package/lib/Discord/gateway/compression/base.d.ts

@@ -0,0 +1,6 @@
+import type Shard from "../Shard";
+export default abstract class Compressor {
+    shard: Shard;
+    abstract decompress(data: Buffer): Promise<Buffer | null>;
+    constructor(shard: Shard);
+}

package/lib/Discord/gateway/compression/base.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Compressor {
+    shard;
+    constructor(shard) {
+        Object.defineProperty(this, "shard", {
+            value: shard,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+}
+exports.default = Compressor;

package/lib/Discord/gateway/compression/config.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Errors_1 = require("../../util/Errors.cjs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+/* eslint-disable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars, @typescript-eslint/no-var-requires, unicorn/prefer-module */
+const CompressionConfigs = {
+    "zlib-stream": [
+        {
+            name: "zlib-sync",
+            check: (client) => client.util._isModuleInstalled("zlib-sync"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-sync")).default,
+            getError: () => new Errors_1.DependencyError("zlib-sync based zlib-stream compression is not available: zlib-sync is not installed")
+        },
+        {
+            name: "pako",
+            check: (client) => client.util._isModuleInstalled("pako"),
+            getClass: () => require(node_path_1.default.join(__dirname, "pako")).default,
+            getError: () => new Errors_1.DependencyError("pako based zlib-stream compression is not available: pako is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createInflate" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-native")).default,
+            getError: () => new Errors_1.DependencyError("native zlib-stream compression is not available: zlib.createInflate does not exist")
+        }
+    ],
+    "zstd-stream": [
+        {
+            name: "zstd-napi",
+            check: (client) => client.util._isModuleInstalled("zstd-napi"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-napi")).default,
+            getError: () => new Errors_1.DependencyError("zstd-napi based zstd-stream compression is not available: zstd-napi is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createZstdDecompress" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-native")).default,
+            getError: () => new Errors_1.DependencyError("native zstd-stream compression is not available: zlib.createZstdDecompress does not exist")
+        }
+    ]
+};
+/* eslint-enable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars */
+exports.default = CompressionConfigs;

package/lib/Discord/gateway/compression/config.d.ts

@@ -0,0 +1,17 @@
+import type Compressor from "./base";
+import type Client from "../../Client";
+import { DependencyError } from "../../util/Errors";
+import type Shard from "../Shard";
+export type CompressionType = "zlib-stream" | "zstd-stream";
+export type CompressionLibrary = "native" | "zlib-sync" | "pako" | "zstd-napi";
+export interface CompressionModule {
+    default: new (shard: Shard) => Compressor;
+}
+export interface CompressionConfig {
+    name: CompressionLibrary;
+    check(client: Client): boolean;
+    getClass(): new (shard: Shard) => Compressor;
+    getError(): DependencyError;
+}
+declare const CompressionConfigs: Record<string, Array<CompressionConfig>>;
+export default CompressionConfigs;

package/lib/Discord/gateway/compression/config.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Errors_1 = require("../../util/Errors");
+const node_path_1 = __importDefault(require("node:path"));
+const node_zlib_1 = __importDefault(require("node:zlib"));
+/* eslint-disable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars, @typescript-eslint/no-var-requires, unicorn/prefer-module */
+const CompressionConfigs = {
+    "zlib-stream": [
+        {
+            name: "zlib-sync",
+            check: (client) => client.util._isModuleInstalled("zlib-sync"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-sync")).default,
+            getError: () => new Errors_1.DependencyError("zlib-sync based zlib-stream compression is not available: zlib-sync is not installed")
+        },
+        {
+            name: "pako",
+            check: (client) => client.util._isModuleInstalled("pako"),
+            getClass: () => require(node_path_1.default.join(__dirname, "pako")).default,
+            getError: () => new Errors_1.DependencyError("pako based zlib-stream compression is not available: pako is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createInflate" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zlib-native")).default,
+            getError: () => new Errors_1.DependencyError("native zlib-stream compression is not available: zlib.createInflate does not exist")
+        }
+    ],
+    "zstd-stream": [
+        {
+            name: "zstd-napi",
+            check: (client) => client.util._isModuleInstalled("zstd-napi"),
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-napi")).default,
+            getError: () => new Errors_1.DependencyError("zstd-napi based zstd-stream compression is not available: zstd-napi is not installed")
+        },
+        {
+            name: "native",
+            check: (_client) => "createZstdDecompress" in node_zlib_1.default,
+            getClass: () => require(node_path_1.default.join(__dirname, "zstd-native")).default,
+            getError: () => new Errors_1.DependencyError("native zstd-stream compression is not available: zlib.createZstdDecompress does not exist")
+        }
+    ]
+};
+/* eslint-enable @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-unused-vars */
+exports.default = CompressionConfigs;

package/lib/Discord/gateway/compression/pako.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const pako_1 = require("pako");
+class PakoCompression extends base_1.default {
+    _sharedZLib;
+    constructor(shard) {
+        super(shard);
+        this._sharedZLib = new pako_1.Inflate({ chunkSize: 128 * 1024 });
+    }
+    async decompress(data) {
+        if (data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF) {
+            // store the current pointer for slicing buffers after pushing.
+            const currentPointer = this._sharedZLib.strm?.next_out;
+            this._sharedZLib.push(data, pako_1.constants.Z_SYNC_FLUSH);
+            if (this._sharedZLib.err) {
+                this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error ${this._sharedZLib.err}: ${this._sharedZLib.msg ?? ""}`, 0));
+                return null;
+            }
+            if (this._sharedZLib.chunks.length === 0) {
+                // The current buffer hasn't been flushed
+                data = Buffer.from(this._sharedZLib.strm.output.slice(currentPointer));
+            }
+            else {
+                // Buffers have been flushed one or more times
+                data = Buffer.concat([
+                    this._sharedZLib.chunks[0].slice(currentPointer),
+                    ...this._sharedZLib.chunks.slice(1),
+                    this._sharedZLib.strm.output
+                ]);
+                this._sharedZLib.chunks = [];
+            }
+            return data;
+        }
+        else {
+            this._sharedZLib.push(data, false);
+            return null;
+        }
+    }
+}
+exports.default = PakoCompression;

package/lib/Discord/gateway/compression/pako.d.ts

@@ -0,0 +1,16 @@
+import Compressor from "./base";
+import type Shard from "../Shard";
+import { Inflate } from "pako";
+interface PakoExtra {
+    chunks: Array<Buffer>;
+    strm: {
+        next_out: number;
+        output: Buffer;
+    };
+}
+export default class PakoCompression extends Compressor {
+    _sharedZLib: Inflate & PakoExtra;
+    constructor(shard: Shard);
+    decompress(data: Buffer): Promise<Buffer | null>;
+}
+export {};

package/lib/Discord/gateway/compression/pako.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base"));
+const Errors_1 = require("../../util/Errors");
+const pako_1 = require("pako");
+class PakoCompression extends base_1.default {
+    _sharedZLib;
+    constructor(shard) {
+        super(shard);
+        this._sharedZLib = new pako_1.Inflate({ chunkSize: 128 * 1024 });
+    }
+    async decompress(data) {
+        if (data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF) {
+            // store the current pointer for slicing buffers after pushing.
+            const currentPointer = this._sharedZLib.strm?.next_out;
+            this._sharedZLib.push(data, pako_1.constants.Z_SYNC_FLUSH);
+            if (this._sharedZLib.err) {
+                this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error ${this._sharedZLib.err}: ${this._sharedZLib.msg ?? ""}`, 0));
+                return null;
+            }
+            if (this._sharedZLib.chunks.length === 0) {
+                // The current buffer hasn't been flushed
+                data = Buffer.from(this._sharedZLib.strm.output.slice(currentPointer));
+            }
+            else {
+                // Buffers have been flushed one or more times
+                data = Buffer.concat([
+                    this._sharedZLib.chunks[0].slice(currentPointer),
+                    ...this._sharedZLib.chunks.slice(1),
+                    this._sharedZLib.strm.output
+                ]);
+                this._sharedZLib.chunks = [];
+            }
+            return data;
+        }
+        else {
+            this._sharedZLib.push(data, false);
+            return null;
+        }
+    }
+}
+exports.default = PakoCompression;

package/lib/Discord/gateway/compression/zlib-native.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = __importDefault(require("./base.cjs"));
+const Errors_1 = require("../../util/Errors.cjs");
+const node_zlib_1 = require("node:zlib");
+class ZlibNativeCompressor extends base_1.default {
+    _chunks;
+    _decompressQueue;
+    stream;
+    constructor(shard) {
+        super(shard);
+        this._chunks = [];
+        this._decompressQueue = Promise.resolve();
+        this.stream = (0, node_zlib_1.createInflate)();
+        this.stream.on("error", err => {
+            this.shard.client.emit("error", new Errors_1.GatewayError(`zlib error: ${String(err)}`, 0));
+        });
+    }
+    async decompress(data) {
+        const isComplete = data.length >= 4 && data.readUInt32BE(data.length - 4) === 0xFFFF;
+        let result = null;
+        this._decompressQueue = this._decompressQueue.then(async () => new Promise(resolve => {
+            // eslint-disable-next-line unicorn/consistent-function-scoping
+            const onData = (chunk) => {
+                this._chunks.push(chunk);
+            };
+            this.stream.on("data", onData);
+            this.stream.write(data, error => {
+                this.stream.off("data", onData);
+                if (error) {
+                    this.shard.client.emit("error", new Errors_1.GatewayError(`Failed to decompress zlib: ${String(error)}`, 0));
+                    result = null;
+                    resolve();
+                    return;
+                }
+                if (isComplete) {
+                    result = this._chunks.length === 0 ? null : Buffer.concat(this._chunks);
+                    this._chunks = [];
+                }
+                resolve();
+            });
+        }));
+        await this._decompressQueue;
+        return result;
+    }
+}
+exports.default = ZlibNativeCompressor;

package/lib/Discord/gateway/compression/zlib-native.d.ts

@@ -0,0 +1,10 @@
+import Compressor from "./base";
+import type Shard from "../Shard";
+import { type Inflate } from "node:zlib";
+export default class ZlibNativeCompressor extends Compressor {
+    _chunks: Array<Buffer>;
+    _decompressQueue: Promise<void>;
+    stream: Inflate;
+    constructor(shard: Shard);
+    decompress(data: Buffer): Promise<Buffer | null>;
+}