lunibee 0.3.3 → 0.4.0

package/dist/ws/index.js

@@ -1,1341 +1,52 @@
 // @bun
-// packages/ws/src/session.ts
-class GatewaySession {
-  #state = { status: "none" };
-  #sequence = null;
-  #generation = 0;
-  #lastInvalidation;
-  get lastInvalidation() {
-    return this.#lastInvalidation;
-  }
-  get generation() {
-    return this.#generation;
-  }
-  get sessionId() {
-    return this.#state.status === "established" ? this.#state.sessionId : undefined;
-  }
-  get resumeURL() {
-    return this.#state.status === "established" ? this.#state.resumeURL : undefined;
-  }
-  get sequence() {
-    return this.#sequence;
-  }
-  get canResume() {
-    return this.#state.status === "established" && this.#sequence !== null;
-  }
-  beginConnection() {
-    return ++this.#generation;
-  }
-  owns(token) {
-    return token === this.#generation;
-  }
-  recordSequence(sequence, token) {
-    if (!this.owns(token))
-      return false;
-    if (!Number.isInteger(sequence))
-      return false;
-    if (this.#sequence !== null && sequence < this.#sequence)
-      return false;
-    this.#sequence = sequence;
-    return true;
-  }
-  activate(payload, token) {
-    if (!this.owns(token))
-      return false;
-    const ready = payload;
-    if (typeof ready?.session_id !== "string" || typeof ready?.resume_gateway_url !== "string")
-      return false;
-    this.#state = {
-      status: "established",
-      sessionId: ready.session_id,
-      resumeURL: ready.resume_gateway_url
-    };
-    return true;
-  }
-  invalidate(token, reason = "explicit") {
-    if (!this.owns(token))
-      return false;
-    this.#lastInvalidation = reason;
-    this.#state = { status: "none" };
-    this.#sequence = null;
-    return true;
-  }
-  resumeInfo() {
-    if (this.#state.status !== "established")
-      return;
-    if (this.#sequence === null)
-      return;
-    const { sessionId, resumeURL } = this.#state;
-    return { sessionId, sequence: this.#sequence, resumeURL };
-  }
-  handshake() {
-    const resume = this.resumeInfo();
-    return resume ? { type: "resume", ...resume } : { type: "identify" };
-  }
-  connectURL(fallback) {
-    const resume = this.resumeInfo()?.resumeURL;
-    return resume !== undefined && isTrustedGatewayURL(resume, fallback) ? resume : fallback;
-  }
-}
-function isTrustedGatewayURL(url, fallback) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    return false;
-  }
-  if (parsed.protocol !== "wss:" || parsed.username || parsed.password)
-    return false;
-  const host = parsed.hostname.toLowerCase();
-  if (host === "discord.gg" || host.endsWith(".discord.gg"))
-    return true;
-  try {
-    return host === new URL(fallback).hostname.toLowerCase();
-  } catch {
-    return false;
-  }
-}
-
-// packages/ws/src/heartbeat.ts
-var MAX_MONITOR_INTERVAL = 1000;
-
-class GatewayHeartbeat {
-  #options;
-  #now;
-  #interval = 0;
-  #acknowledged = true;
-  #sentAt = 0;
-  #latency = -1;
-  #lastMessageAt = 0;
-  #zombieReported = false;
-  #timer;
-  #initialTimer;
-  #ackTimer;
-  #monitorTimer;
-  constructor(options) {
-    if (options.zombieTimeout <= options.ackTimeout)
-      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
-    this.#options = options;
-    this.#now = options.now ?? (() => Date.now());
-  }
-  get latency() {
-    return this.#latency;
-  }
-  get interval() {
-    return this.#interval;
-  }
-  get acknowledged() {
-    return this.#acknowledged;
-  }
-  get silentFor() {
-    return this.#lastMessageAt === 0 ? 0 : this.#now() - this.#lastMessageAt;
-  }
-  get stalenessDeadline() {
-    return Math.max(this.#options.zombieTimeout, this.#interval + this.#options.ackTimeout);
-  }
-  isHealthy() {
-    if (!this.#acknowledged)
-      return false;
-    if (this.#lastMessageAt === 0)
-      return true;
-    return this.silentFor < this.stalenessDeadline;
-  }
-  watch() {
-    this.#lastMessageAt = this.#now();
-    this.#zombieReported = false;
-    this.#startMonitor();
-  }
-  receivedMessage() {
-    this.#lastMessageAt = this.#now();
-    this.#zombieReported = false;
-  }
-  start(interval) {
-    this.#clearBeatTimers();
-    this.#interval = interval;
-    this.#acknowledged = true;
-    this.#initialTimer = setTimeout(() => {
-      this.#initialTimer = undefined;
-      this.sendHeartbeat();
-      this.#timer = setInterval(() => this.sendHeartbeat(), interval);
-    }, Math.random() * interval);
-  }
-  stop() {
-    this.#clearBeatTimers();
-    if (this.#monitorTimer)
-      clearInterval(this.#monitorTimer);
-    this.#monitorTimer = undefined;
-  }
-  sendHeartbeat() {
-    this.#acknowledged = false;
-    this.#sentAt = this.#now();
-    if (!this.#options.send(this.#options.sequence())) {
-      this.#options.onError(new Error("Unable to send Gateway heartbeat because the WebSocket is not open."));
-      return;
-    }
-    this.#clearAckTimer();
-    this.#ackTimer = setTimeout(() => {
-      if (this.#acknowledged)
-        return;
-      this.#options.onTimeout({
-        type: "ack",
-        elapsedMs: this.#now() - this.#sentAt
-      });
-    }, this.#options.ackTimeout);
-  }
-  acknowledge() {
-    if (this.#acknowledged)
-      return;
-    this.#acknowledged = true;
-    this.#latency = this.#now() - this.#sentAt;
-    this.#clearAckTimer();
-  }
-  #startMonitor() {
-    if (this.#monitorTimer)
-      clearInterval(this.#monitorTimer);
-    const interval = Math.max(1, Math.min(MAX_MONITOR_INTERVAL, this.#options.ackTimeout, this.#options.zombieTimeout / 2));
-    this.#monitorTimer = setInterval(() => this.#checkStaleness(), interval);
-  }
-  #checkStaleness() {
-    if (!this.#options.isConnected() || this.#lastMessageAt === 0)
-      return;
-    const silentFor = this.silentFor;
-    const deadline = this.stalenessDeadline;
-    if (silentFor < deadline || this.#zombieReported)
-      return;
-    this.#zombieReported = true;
-    this.#options.onTimeout({ type: "zombie", silentFor, deadline });
-  }
-  #clearAckTimer() {
-    if (this.#ackTimer)
-      clearTimeout(this.#ackTimer);
-    this.#ackTimer = undefined;
-  }
-  #clearBeatTimers() {
-    if (this.#timer)
-      clearInterval(this.#timer);
-    if (this.#initialTimer)
-      clearTimeout(this.#initialTimer);
-    this.#clearAckTimer();
-    this.#timer = undefined;
-    this.#initialTimer = undefined;
-  }
-}
-
-// packages/ws/src/close-codes.ts
-var GatewayCloseCodes = {
-  UnknownError: 4000,
-  UnknownOpcode: 4001,
-  DecodeError: 4002,
-  NotAuthenticated: 4003,
-  AuthenticationFailed: 4004,
-  AlreadyAuthenticated: 4005,
-  InvalidSeq: 4007,
-  RateLimited: 4008,
-  SessionTimedOut: 4009,
-  InvalidShard: 4010,
-  ShardingRequired: 4011,
-  InvalidAPIVersion: 4012,
-  InvalidIntents: 4013,
-  DisallowedIntents: 4014
-};
-
-// packages/ws/src/reconnect.ts
-var FATAL_CLOSE_CODES = [
-  GatewayCloseCodes.AuthenticationFailed,
-  GatewayCloseCodes.InvalidShard,
-  GatewayCloseCodes.ShardingRequired,
-  GatewayCloseCodes.InvalidAPIVersion,
-  GatewayCloseCodes.InvalidIntents,
-  GatewayCloseCodes.DisallowedIntents
-];
-var IDENTIFY_CLOSE_CODES = [
-  GatewayCloseCodes.InvalidSeq,
-  GatewayCloseCodes.SessionTimedOut
-];
-function classifyCloseCode(code, canResume) {
-  if (FATAL_CLOSE_CODES.includes(code))
-    return "stop";
-  if (IDENTIFY_CLOSE_CODES.includes(code))
-    return "identify";
-  return canResume ? "resume" : "identify";
-}
-
-class GatewayReconnect {
-  #options;
-  #random;
-  #attempt = 0;
-  #recent = [];
-  #timer;
-  #promise;
-  #resolve;
-  #reject;
-  constructor(options) {
-    this.#options = options;
-    this.#random = options.random ?? Math.random;
-  }
-  get enabled() {
-    return this.#options.enabled;
-  }
-  get attempts() {
-    return this.#attempt;
-  }
-  get pending() {
-    return this.#timer !== undefined;
-  }
-  get exhausted() {
-    return this.#attempt >= this.#options.maxAttempts;
-  }
-  get connecting() {
-    return this.#promise !== undefined;
-  }
-  get attemptPromise() {
-    return this.#promise;
-  }
-  classifyClose(code, canResume) {
-    return classifyCloseCode(code, canResume);
-  }
-  canReconnect() {
-    return this.#options.enabled && !this.exhausted;
-  }
-  schedule(run) {
-    if (!this.#options.enabled)
-      return { scheduled: false, reason: "disabled" };
-    if (this.#timer)
-      return { scheduled: false, reason: "pending" };
-    if (this.exhausted)
-      return { scheduled: false, reason: "exhausted" };
-    const attempt = this.#attempt;
-    const now = (this.#options.now ?? Date.now)();
-    const window = this.#options.stormWindow ?? 60000;
-    const limit = this.#options.stormLimit ?? 5;
-    while (this.#recent.length && now - this.#recent[0] >= window)
-      this.#recent.shift();
-    const over = this.#recent.length - limit;
-    this.#recent.push(now);
-    let delay = Math.min(this.#options.maxDelay, this.#options.baseDelay * 2 ** this.#attempt++);
-    const unstable = over >= 0;
-    if (unstable)
-      delay = Math.min(this.#options.maxDelay, Math.max(delay, this.#options.baseDelay * 2 ** (over + 1)));
-    const jitter = this.#random() * Math.max(1, delay * 0.25);
-    const delayMs = delay + jitter;
-    this.#timer = setTimeout(() => {
-      this.#timer = undefined;
-      run();
-    }, delayMs);
-    return {
-      scheduled: true,
-      delayMs,
-      attempt,
-      ...unstable ? { unstable: { reconnects: this.#recent.length } } : {}
-    };
-  }
-  cancel() {
-    if (this.#timer)
-      clearTimeout(this.#timer);
-    this.#timer = undefined;
-  }
-  reset() {
-    this.#attempt = 0;
-  }
-  attempt(start) {
-    if (this.#promise)
-      return this.#promise;
-    this.#promise = new Promise((resolve, reject) => {
-      this.#resolve = resolve;
-      this.#reject = reject;
-      start();
-    });
-    return this.#promise;
-  }
-  settle(error) {
-    const resolve = this.#resolve;
-    const reject = this.#reject;
-    this.#resolve = undefined;
-    this.#reject = undefined;
-    this.#promise = undefined;
-    if (error)
-      reject?.(error);
-    else
-      resolve?.();
-  }
-}
-
-// packages/ws/src/decoder.ts
 import {
-  createInflate,
-  constants as zlibConstants
-} from "zlib";
-async function toBytes(data) {
-  if (data instanceof Uint8Array)
-    return data;
-  if (data instanceof ArrayBuffer)
-    return new Uint8Array(data);
-  if (typeof Blob !== "undefined" && data instanceof Blob)
-    return new Uint8Array(await data.arrayBuffer());
-  throw new TypeError("Gateway returned an unsupported compressed frame type.");
-}
-
-class PlainTextDecoder {
-  push(data) {
-    return [String(data)];
-  }
-  reset() {}
-}
-
-class ZlibStreamDecoder {
-  #create;
-  #maxFrameBytes;
-  #inflate;
-  #chunks = [];
-  #size = 0;
-  #failure;
-  #pendingReject;
-  constructor(create = () => createInflate(), maxFrameBytes = 64 * 1024 * 1024) {
-    this.#create = create;
-    this.#maxFrameBytes = maxFrameBytes;
-  }
-  push(data) {
-    if (typeof data === "string")
-      return [data];
-    return this.#inflateFrame(data);
-  }
-  async#inflateFrame(data) {
-    const chunk = await toBytes(data);
-    const inflate = this.#inflate ??= this.#open();
-    if (this.#failure)
-      throw this.#failure;
-    const complete = chunk.length >= 4 && chunk[chunk.length - 4] === 0 && chunk[chunk.length - 3] === 0 && chunk[chunk.length - 2] === 255 && chunk[chunk.length - 1] === 255;
-    await this.#awaiting((settle) => inflate.write(chunk, (error) => error ? settle(error) : settle()));
-    if (!complete)
-      return [];
-    await this.#awaiting((settle) => inflate.flush(zlibConstants.Z_SYNC_FLUSH, () => settle()));
-    const parts = this.#chunks;
-    this.#chunks = [];
-    this.#size = 0;
-    if (parts.length === 0)
-      return [];
-    const total = parts.reduce((size, part) => size + part.length, 0);
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const part of parts) {
-      merged.set(part, offset);
-      offset += part.length;
-    }
-    return [new TextDecoder().decode(merged)];
-  }
-  reset() {
-    const inflate = this.#inflate;
-    this.#inflate = undefined;
-    this.#chunks = [];
-    this.#size = 0;
-    this.#failure = undefined;
-    this.#pendingReject = undefined;
-    if (!inflate)
-      return;
-    inflate.removeAllListeners();
-    try {
-      inflate.close();
-    } catch {}
-  }
-  #awaiting(run) {
-    if (this.#failure)
-      return Promise.reject(this.#failure);
-    return new Promise((resolve, reject) => {
-      this.#pendingReject = reject;
-      run((error) => {
-        this.#pendingReject = undefined;
-        if (error)
-          reject(error);
-        else if (this.#failure)
-          reject(this.#failure);
-        else
-          resolve();
-      });
-    });
-  }
-  #open() {
-    const inflate = this.#create();
-    inflate.on("data", (chunk) => {
-      if (this.#failure)
-        return;
-      this.#size += chunk.length;
-      if (this.#size > this.#maxFrameBytes) {
-        this.#chunks = [];
-        inflate.emit("error", new Error(`Gateway frame inflated past ${this.#maxFrameBytes} bytes.`));
-        return;
-      }
-      this.#chunks.push(chunk);
-    });
-    inflate.on("error", (error) => {
-      this.#failure = error;
-      const reject = this.#pendingReject;
-      this.#pendingReject = undefined;
-      reject?.(error);
-    });
-    return inflate;
-  }
-}
-function createDecoder(compress) {
-  return compress ? new ZlibStreamDecoder : new PlainTextDecoder;
-}
-
-// packages/ws/src/transport.ts
-var OPEN = 1;
-
-class WebSocketTransport {
-  #handlers;
-  #decoder;
-  #createSocket;
-  #compress;
-  #socket;
-  #generation = 0;
-  #queue = Promise.resolve();
-  constructor(options) {
-    this.#handlers = options.handlers;
-    this.#compress = options.compress ?? false;
-    this.#decoder = options.decoder ?? createDecoder(options.compress);
-    this.#createSocket = options.createSocket ?? ((url) => new WebSocket(url));
-  }
-  get connected() {
-    return this.#socket?.readyState === OPEN;
-  }
-  get live() {
-    return this.#socket !== undefined && this.#socket.readyState <= OPEN;
-  }
-  get generation() {
-    return this.#generation;
-  }
-  connect(url) {
-    this.#discard(1000, "Superseded by a new connection");
-    const generation = ++this.#generation;
-    this.#decoder.reset();
-    this.#queue = Promise.resolve();
-    let socket;
-    try {
-      socket = this.#createSocket(url);
-    } catch (error) {
-      return { ok: false, error: this.#asError(error) };
-    }
-    if (this.#compress) {
-      try {
-        socket.binaryType = "arraybuffer";
-      } catch {}
-    }
-    this.#socket = socket;
-    socket.addEventListener("open", () => {
-      if (!this.#owns(generation))
-        return;
-      this.#handlers.onOpen();
-    });
-    socket.addEventListener("message", (event) => {
-      if (!this.#owns(generation))
-        return;
-      let decoded;
-      try {
-        decoded = this.#decoder.push(event.data);
-      } catch (error) {
-        this.#handlers.onError(this.#asError(error));
-        this.#failDecoding(generation);
-        return;
-      }
-      if (!(decoded instanceof Promise)) {
-        for (const frame of decoded)
-          this.#handlers.onFrame(frame);
-        return;
-      }
-      this.#queue = this.#queue.then(async () => {
-        const frames = await decoded;
-        if (!this.#owns(generation))
-          return;
-        for (const frame of frames)
-          this.#handlers.onFrame(frame);
-      }).catch((error) => {
-        if (!this.#owns(generation))
-          return;
-        this.#handlers.onError(this.#asError(error));
-        this.#failDecoding(generation);
-      });
-    });
-    socket.addEventListener("close", (event) => {
-      if (!this.#owns(generation))
-        return;
-      this.#socket = undefined;
-      this.#generation++;
-      this.#decoder.reset();
-      this.#handlers.onClose(event.code, event.reason ?? "");
-    });
-    socket.addEventListener("error", () => {
-      if (!this.#owns(generation))
-        return;
-      this.#handlers.onError(new Error("Gateway WebSocket error"));
-    });
-    return { ok: true };
-  }
-  send(data) {
-    if (!this.connected)
-      return false;
-    try {
-      this.#socket.send(data);
-      return true;
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-      return false;
-    }
-  }
-  #failDecoding(generation) {
-    if (this.#owns(generation))
-      this.close(4000, "decoder failure");
-  }
-  close(code = 1000, reason = "") {
-    const socket = this.#socket;
-    if (!socket)
-      return;
-    try {
-      socket.close(code, reason);
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-    }
-  }
-  destroy(code = 1000, reason = "") {
-    this.#discard(code, reason);
-    this.#decoder.reset();
-  }
-  #owns(generation) {
-    return generation === this.#generation;
-  }
-  #discard(code, reason) {
-    const socket = this.#socket;
-    if (!socket)
-      return;
-    this.#generation++;
-    this.#socket = undefined;
-    try {
-      socket.close(code, reason);
-    } catch (error) {
-      this.#handlers.onError(this.#asError(error));
-    }
-  }
-  #asError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-  }
-}
-
-// packages/ws/src/opcodes.ts
-var GatewayOpcodes = {
-  Dispatch: 0,
-  Heartbeat: 1,
-  Identify: 2,
-  PresenceUpdate: 3,
-  VoiceStateUpdate: 4,
-  Resume: 6,
-  Reconnect: 7,
-  RequestGuildMembers: 8,
-  InvalidSession: 9,
-  Hello: 10,
-  HeartbeatAck: 11
-};
-
-// packages/ws/src/protocol.ts
-function classifyFrame(raw) {
-  let payload;
-  try {
-    payload = JSON.parse(raw);
-  } catch (error) {
-    return {
-      sequence: null,
-      action: {
-        type: "invalid",
-        violation: "invalid-json",
-        message: "Gateway returned invalid JSON",
-        cause: error
-      }
-    };
-  }
-  return classifyPayload(payload);
-}
-function classifyPayload(payload) {
-  if (payload === null || typeof payload !== "object" || typeof payload.op !== "number")
-    return {
-      sequence: null,
-      action: {
-        type: "invalid",
-        violation: "invalid-payload",
-        message: "Gateway returned an invalid payload"
-      }
-    };
-  const frame = payload;
-  const sequence = typeof frame.s === "number" ? frame.s : null;
-  switch (frame.op) {
-    case GatewayOpcodes.Dispatch:
-      return {
-        sequence,
-        action: {
-          type: "dispatch",
-          event: typeof frame.t === "string" ? frame.t : null,
-          data: frame.d
-        }
-      };
-    case GatewayOpcodes.Hello: {
-      const interval = frame.d?.heartbeat_interval;
-      if (typeof interval !== "number" || !Number.isFinite(interval) || interval <= 0)
-        return {
-          sequence,
-          action: {
-            type: "invalid",
-            violation: "invalid-hello",
-            message: "Gateway HELLO payload contains an invalid heartbeat interval"
-          }
-        };
-      return {
-        sequence,
-        action: { type: "hello", heartbeatInterval: interval }
-      };
-    }
-    case GatewayOpcodes.Heartbeat:
-      return { sequence, action: { type: "heartbeat" } };
-    case GatewayOpcodes.HeartbeatAck:
-      return {
-        sequence,
-        action: { type: "heartbeat-ack", data: frame.d }
-      };
-    case GatewayOpcodes.Reconnect:
-      return { sequence, action: { type: "reconnect" } };
-    case GatewayOpcodes.InvalidSession:
-      return {
-        sequence,
-        action: {
-          type: "invalid-session",
-          resumable: frame.d === true
-        }
-      };
-    default:
-      return { sequence, action: { type: "unknown", opcode: frame.op } };
-  }
-}
-function identifyPayload(options) {
-  const props = options.properties ?? {};
-  const os = props.os ?? process.platform;
-  const browser = props.browser ?? "Lunibee";
-  const device = props.device ?? "Lunibee";
-  return {
-    op: GatewayOpcodes.Identify,
-    d: {
-      token: options.token,
-      intents: options.intents,
-      properties: {
-        os,
-        browser,
-        device,
-        $os: os,
-        $browser: browser,
-        $device: device,
-        ...props
-      },
-      presence: {
-        since: options.presence?.since ?? null,
-        activities: options.presence?.activities ?? [],
-        status: options.presence?.status ?? "online",
-        afk: Boolean(options.presence?.afk)
-      },
-      shard: [options.shardId, options.shardCount]
-    },
-    s: null,
-    t: null
-  };
-}
-function resumePayload(token, resume) {
-  return {
-    op: GatewayOpcodes.Resume,
-    d: {
-      token,
-      session_id: resume.sessionId,
-      seq: resume.sequence
-    },
-    s: null,
-    t: null
-  };
-}
-function heartbeatPayload(sequence) {
-  return { op: GatewayOpcodes.Heartbeat, d: sequence, s: null, t: null };
-}
-
-// packages/types/src/channel-kind.ts
-var ChannelKinds = {
-  text: [0],
-  dm: [1],
-  voice: [2],
-  "group-dm": [3],
-  category: [4],
-  announcement: [5],
-  thread: [10, 11, 12],
-  stage: [13],
-  directory: [14],
-  forum: [15],
-  media: [16]
-};
-var KIND_OF_TYPE = new Map(Object.keys(ChannelKinds).flatMap((kind) => ChannelKinds[kind].map((type) => [type, kind])));
-// packages/types/src/gateway.ts
-var GatewayIntentBits = {
-  Guilds: 1 << 0,
-  GuildMembers: 1 << 1,
-  GuildModeration: 1 << 2,
-  GuildExpressions: 1 << 3,
-  GuildIntegrations: 1 << 4,
-  GuildWebhooks: 1 << 5,
-  GuildInvites: 1 << 6,
-  GuildVoiceStates: 1 << 7,
-  GuildPresences: 1 << 8,
-  GuildMessages: 1 << 9,
-  GuildMessageReactions: 1 << 10,
-  GuildMessageTyping: 1 << 11,
-  DirectMessages: 1 << 12,
-  DirectMessageReactions: 1 << 13,
-  DirectMessageTyping: 1 << 14,
-  MessageContent: 1 << 15,
-  GuildScheduledEvents: 1 << 16,
-  AutoModerationConfiguration: 1 << 20,
-  AutoModerationExecution: 1 << 21,
-  GuildMessagePolls: 1 << 24,
-  DirectMessagePolls: 1 << 25
-};
-var IntentBits = {
-  guild: 1 << 0,
-  guilds: 1 << 0,
-  guildMembers: 1 << 1,
-  guildModeration: 1 << 2,
-  guildBans: 1 << 2,
-  guildExpressions: 1 << 3,
-  guildEmojis: 1 << 3,
-  guildEmojisAndStickers: 1 << 3,
-  guildIntegrations: 1 << 4,
-  guildWebhooks: 1 << 5,
-  guildInvites: 1 << 6,
-  guildVoiceStates: 1 << 7,
-  guildPresences: 1 << 8,
-  guildMessages: 1 << 9,
-  guildMessage: 1 << 9,
-  guildMessageReactions: 1 << 10,
-  guildMessageTyping: 1 << 11,
-  directMessages: 1 << 12,
-  directMessageReactions: 1 << 13,
-  directMessageTyping: 1 << 14,
-  messageContent: 1 << 15,
-  guildScheduledEvents: 1 << 16,
-  autoModerationConfiguration: 1 << 20,
-  autoModerationExecution: 1 << 21,
-  guildMessagePolls: 1 << 24,
-  directMessagePolls: 1 << 25
-};
-function resolveGatewayIntents(intents) {
-  if (!Array.isArray(intents))
-    throw new TypeError("Gateway intents must be an array, e.g. [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages].");
-  return intents.reduce((acc, intent) => acc | resolveIntent(intent), 0);
-}
-function resolveIntent(intent) {
-  if (typeof intent === "number")
-    return intent;
-  const bits = {
-    ...IntentBits,
-    ...GatewayIntentBits
-  };
-  const lower = intent.charAt(0).toLowerCase() + intent.slice(1);
-  if (Object.hasOwn(bits, intent))
-    return bits[intent];
-  if (Object.hasOwn(bits, lower))
-    return bits[lower];
-  const num = Number(intent);
-  return Number.isNaN(num) ? 0 : num;
-}
-// packages/ws/src/dispatcher.ts
-class GatewayDispatcher {
-  #listeners = new Map;
-  #onFailure;
-  constructor(onFailure) {
-    this.#onFailure = onFailure;
-  }
-  on(event, listener) {
-    let listeners = this.#listeners.get(event);
-    if (!listeners)
-      this.#listeners.set(event, listeners = new Set);
-    listeners.add(listener);
-  }
-  off(event, listener) {
-    this.#listeners.get(event)?.delete(listener);
-  }
-  emit(event, data) {
-    for (const listener of this.#listeners.get(event) ?? []) {
-      try {
-        const result = listener(data);
-        if (result && typeof result.then === "function")
-          Promise.resolve(result).catch((error) => {
-            if (event !== "error")
-              this.#onFailure(error);
-          });
-      } catch (error) {
-        if (event !== "error")
-          this.#onFailure(error);
-      }
-    }
-  }
-}
-// packages/ws/src/send-budget.ts
-class GatewaySendLimiter {
-  #timestamps = [];
-  #limit;
-  #windowMs;
-  constructor(limit = 115, windowMs = 60000) {
-    this.#limit = limit;
-    this.#windowMs = windowMs;
-  }
-  get used() {
-    return this.#timestamps.length;
-  }
-  allows(privileged, now = Date.now()) {
-    while (this.#timestamps.length && now - this.#timestamps[0] >= this.#windowMs)
-      this.#timestamps.shift();
-    return privileged || this.#timestamps.length < this.#limit;
-  }
-  record(now = Date.now()) {
-    this.#timestamps.push(now);
-  }
-}
-var SendBudget = GatewaySendLimiter;
-// packages/ws/src/state.ts
-var GatewayState;
-((GatewayState) => {
-  GatewayState["Connect"] = "CONNECT";
-  GatewayState["Hello"] = "HELLO";
-  GatewayState["Identify"] = "IDENTIFY";
-  GatewayState["Resume"] = "RESUME";
-  GatewayState["Ready"] = "READY";
-  GatewayState["Dispatch"] = "DISPATCH";
-  GatewayState["Heartbeat"] = "HEARTBEAT";
-  GatewayState["Reconnect"] = "RECONNECT";
-  GatewayState["Closed"] = "CLOSED";
-})(GatewayState ||= {});
-class GatewayError extends Error {
-  code;
-  constructor(message, code, options) {
-    super(message, options);
-    this.name = "GatewayError";
-    this.code = code;
-  }
-}
-// packages/ws/src/index.ts
-var RESUMABLE_CLOSE_CODE = 4900;
-var DEFAULT_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
-
-class Gateway {
-  state = "CONNECT" /* Connect */;
-  #options;
-  #transport;
-  #session = new GatewaySession;
-  #token = 0;
-  #heartbeat;
-  #closed = false;
-  #reconnect;
-  #events = new GatewayDispatcher((error) => this.#emitError(error));
-  #sendBudget = new GatewaySendLimiter;
-  #reconnects = 0;
-  ping = -1;
-  constructor(options) {
-    if (!options.token?.trim())
-      throw new TypeError("A Gateway token is required.");
-    for (const key of [
-      "reconnectBaseDelay",
-      "reconnectMaxDelay",
-      "connectTimeout"
-    ])
-      if (options[key] !== undefined && !(options[key] > 0))
-        throw new RangeError(`Gateway ${key} must be greater than 0.`);
-    const resolvedIntents = resolveGatewayIntents(options.intents);
-    if (!Number.isInteger(resolvedIntents) || resolvedIntents < 0)
-      throw new TypeError("Gateway intents must be a non-negative integer.");
-    this.#options = {
-      shardId: 0,
-      shardCount: 1,
-      reconnect: true,
-      maxReconnectAttempts: Infinity,
-      connectTimeout: 30000,
-      reconnectBaseDelay: 1000,
-      reconnectMaxDelay: 30000,
-      heartbeatAckTimeout: 1e4,
-      zombieTimeout: 30000,
-      properties: {
-        os: process.platform,
-        browser: "Lunibee",
-        device: "Lunibee"
-      },
-      presence: {
-        status: "online",
-        activities: [],
-        afk: false,
-        since: null
-      },
-      ...options,
-      intents: resolvedIntents
-    };
-    if (this.#options.shardId < 0 || this.#options.shardId >= this.#options.shardCount)
-      throw new RangeError("Gateway shardId must be within the configured shard count.");
-    if (this.#options.zombieTimeout <= this.#options.heartbeatAckTimeout)
-      throw new RangeError("Gateway zombieTimeout must be greater than heartbeatAckTimeout");
-    this.#transport = new WebSocketTransport({
-      compress: this.#options.compress,
-      createSocket: options.createSocket,
-      handlers: {
-        onOpen: () => this.#onOpen(),
-        onFrame: (raw) => this.#message(raw, this.#token),
-        onClose: (code) => this.#close(code, this.#token),
-        onError: (error) => this.#emitError(error instanceof GatewayError ? error : new GatewayError(error.message, undefined, {
-          cause: error
-        }))
-      }
-    });
-    this.#reconnect = new GatewayReconnect({
-      enabled: this.#options.reconnect,
-      maxAttempts: this.#options.maxReconnectAttempts,
-      baseDelay: this.#options.reconnectBaseDelay,
-      maxDelay: this.#options.reconnectMaxDelay,
-      stormLimit: options.reconnectStormLimit,
-      stormWindow: options.reconnectStormWindow
-    });
-    this.#heartbeat = new GatewayHeartbeat({
-      ackTimeout: this.#options.heartbeatAckTimeout,
-      zombieTimeout: this.#options.zombieTimeout,
-      send: (sequence) => this.#dispatch(heartbeatPayload(sequence), true),
-      sequence: () => this.#session.sequence,
-      isConnected: () => !this.#closed && this.#transport.connected,
-      onTimeout: (timeout) => this.#onHeartbeatTimeout(timeout),
-      onError: (error) => this.#emitError(error)
-    });
-  }
-  #onHeartbeatTimeout(timeout) {
-    if (timeout.type === "zombie") {
-      this.#emit("zombie", {
-        silentFor: timeout.silentFor,
-        timeout: timeout.deadline
-      });
-      this.#emitError(new GatewayError(`Gateway connection appears stale after ${timeout.silentFor}ms without traffic.`));
-    } else {
-      this.#emitError(new GatewayError(`Gateway heartbeat acknowledgement timed out after ${timeout.elapsedMs}ms.`));
-    }
-    this.#transport.close(RESUMABLE_CLOSE_CODE, timeout.type === "zombie" ? "Zombie Gateway connection" : "Heartbeat timeout");
-  }
-  connect(url = DEFAULT_GATEWAY_URL) {
-    if (this.state === "CLOSED" /* Closed */)
-      return Promise.reject(new GatewayError("Gateway has been permanently closed."));
-    const inFlight = this.#reconnect.attemptPromise;
-    if (inFlight)
-      return inFlight;
-    if (this.#transport.live)
-      return Promise.resolve();
-    this.#reconnect.cancel();
-    this.#closed = false;
-    this.#setState("CONNECT" /* Connect */);
-    const connectURL = this.#options.compress ? url.includes("compress=") ? url : `${url}${url.includes("?") ? "&" : "?"}compress=zlib-stream` : url;
-    return this.#reconnect.attempt(() => this.#open(connectURL));
-  }
-  close() {
-    this.#closed = true;
-    this.#clearTimers();
-    this.#settleConnect(new GatewayError("Gateway connection closed before socket open."));
-    this.#transport.destroy(1000, "Client closed connection");
-    this.#setState("CLOSED" /* Closed */);
-  }
-  emit(event, data) {
-    this.#emit(event, data);
-  }
-  on(event, listener) {
-    if (!event || typeof listener !== "function")
-      throw new TypeError("Gateway event and listener are required.");
-    this.#events.on(event, listener);
-    return this;
-  }
-  off(event, listener) {
-    this.#events.off(event, listener);
-    return this;
-  }
-  health() {
-    return {
-      state: this.state,
-      latency: this.#heartbeat.latency,
-      silentFor: this.#heartbeat.silentFor,
-      reconnects: this.#reconnects
-    };
-  }
-  send(payload) {
-    if (!payload || !Number.isInteger(payload.op))
-      throw new TypeError("Gateway payload must contain an integer opcode.");
-    return this.#dispatch(payload, false);
-  }
-  #dispatch(payload, privileged) {
-    if (!this.#transport.connected)
-      return false;
-    const now = Date.now();
-    if (!this.#sendBudget.allows(privileged, now)) {
-      this.#emitError(new GatewayError("Gateway send rate budget exhausted."));
-      return false;
-    }
-    if (!this.#transport.send(JSON.stringify(payload)))
-      return false;
-    this.#sendBudget.record(now);
-    return true;
-  }
-  setPresence(data) {
-    this.#options.presence = { ...this.#options.presence, ...data };
-    const payload = {
-      since: this.#options.presence.since ?? null,
-      activities: this.#options.presence.activities ?? [],
-      status: this.#options.presence.status ?? "online",
-      afk: Boolean(this.#options.presence.afk)
-    };
-    return this.send({
-      op: GatewayOpcodes.PresenceUpdate,
-      d: payload,
-      s: null,
-      t: null
-    });
-  }
-  setVoiceState(data) {
-    return this.send({
-      op: GatewayOpcodes.VoiceStateUpdate,
-      d: data,
-      s: null,
-      t: null
-    });
-  }
-  sendVoiceState(guildId, channelId, options = {}) {
-    if (!this.ownsGuild(guildId))
-      return false;
-    return this.setVoiceState({
-      guild_id: guildId,
-      channel_id: channelId,
-      self_mute: options.selfMute ?? false,
-      self_deaf: options.selfDeaf ?? false
-    });
-  }
-  ownsGuild(guildId) {
-    const count = this.#options.shardCount;
-    if (count <= 1)
-      return true;
-    if (!/^\d{1,20}$/.test(guildId))
-      return false;
-    return Number((BigInt(guildId) >> 22n) % BigInt(count)) === this.#options.shardId;
-  }
-  requestGuildMembers(data) {
-    return this.send({
-      op: GatewayOpcodes.RequestGuildMembers,
-      d: data,
-      s: null,
-      t: null
-    });
-  }
-  #open(url) {
-    if (this.#closed)
-      return;
-    this.#token = this.#session.beginConnection();
-    const result = this.#transport.connect(url);
-    if (result.ok) {
-      const token = this.#token;
-      clearTimeout(this.#connectTimer);
-      this.#connectTimer = setTimeout(() => {
-        if (token === this.#token && !this.#closed)
-          this.#transport.close(4000, "connect timeout");
-      }, this.#options.connectTimeout);
-      this.#connectTimer.unref?.();
-      return;
-    }
-    const failure = this.#normalizeError(result.error);
-    this.#emitError(failure);
-    if (this.#options.reconnect) {
-      this.#setState("RECONNECT" /* Reconnect */);
-      this.#scheduleReconnect();
-    } else {
-      this.#settleConnect(failure);
-    }
-  }
-  #connectTimer;
-  #onOpen() {
-    clearTimeout(this.#connectTimer);
-    this.#heartbeat.watch();
-    this.#emit("open", undefined);
-    this.#settleConnect();
-  }
-  #message(raw, token) {
-    if (!this.#session.owns(token))
-      return;
-    this.#heartbeat.receivedMessage();
-    const { sequence, action } = classifyFrame(raw);
-    if (sequence !== null)
-      this.#session.recordSequence(sequence, token);
-    this.#apply(action, token);
-  }
-  #apply(action, token) {
-    switch (action.type) {
-      case "dispatch":
-        this.#setState("DISPATCH" /* Dispatch */);
-        this.#handleDispatch(action.event, action.data, token);
-        return;
-      case "hello":
-        this.#handleHello(action.heartbeatInterval);
-        return;
-      case "heartbeat":
-        this.#setState("HEARTBEAT" /* Heartbeat */);
-        this.#heartbeat.sendHeartbeat();
-        return;
-      case "heartbeat-ack":
-        this.#heartbeat.acknowledge();
-        this.ping = this.#heartbeat.latency;
-        this.#emit("heartbeatAck", action.data);
-        return;
-      case "reconnect":
-        this.#transport.close(RESUMABLE_CLOSE_CODE, "Server requested reconnect");
-        return;
-      case "invalid-session": {
-        if (!action.resumable)
-          this.#session.invalidate(token, "invalid-session");
-        this.#emit("invalidSession", action.resumable);
-        this.#transport.close(action.resumable ? GatewayCloseCodes.UnknownError : 1000, action.resumable ? "Invalid session (resumable)" : "Invalid session");
-        return;
-      }
-      case "invalid":
-        this.#emitError(new GatewayError(action.message, undefined, action.cause === undefined ? undefined : { cause: action.cause }));
-        this.#transport.close(1002, action.violation === "invalid-json" ? "Invalid JSON" : action.violation === "invalid-hello" ? "Invalid heartbeat interval" : "Invalid payload");
-        return;
-      case "unknown":
-        return;
-    }
-  }
-  #handleDispatch(event, data, token) {
-    if (event === "READY") {
-      if (!this.#session.activate(data, token)) {
-        if (this.#session.owns(token))
-          this.#emitError(new GatewayError("Gateway READY payload is missing session information"));
-        return;
-      }
-      this.#reconnect.reset();
-      this.#setState("READY" /* Ready */);
-      this.#emit("ready", data);
-    } else if (event === "RESUMED") {
-      this.#reconnect.reset();
-      this.#setState("READY" /* Ready */);
-      this.#emit("resumed", data);
-    }
-    this.#emit("RAW", { event: event ?? "UNKNOWN", data });
-    if (this.#closed)
-      return;
-    if (event == null || /^[A-Z][A-Z0-9_]*$/.test(event))
-      this.#emit(event ?? "dispatch", data);
-  }
-  #handleHello(interval) {
-    this.#setState(this.#session.canResume ? "RESUME" /* Resume */ : "HELLO" /* Hello */);
-    this.#heartbeat.start(interval);
-    this.#identifyOrResume();
-  }
-  #identifyOrResume() {
-    const intent = this.#session.handshake();
-    if (intent.type === "resume") {
-      this.#setState("RESUME" /* Resume */);
-      this.#dispatch(resumePayload(this.#options.token, intent), true);
-      return;
-    }
-    this.#setState("IDENTIFY" /* Identify */);
-    this.#dispatch(identifyPayload({
-      token: this.#options.token,
-      intents: this.#options.intents,
-      shardId: this.#options.shardId,
-      shardCount: this.#options.shardCount,
-      properties: this.#options.properties,
-      presence: this.#options.presence
-    }), true);
-  }
-  #close(code, token) {
-    this.#clearTimers();
-    const action = this.#reconnect.classifyClose(code, this.#session.canResume);
-    this.#emit("close", { code, action });
-    if (this.#closed || !this.#reconnect.enabled || action === "stop") {
-      if (action === "stop")
-        this.#closed = true;
-      this.#setState(this.#closed ? "CLOSED" /* Closed */ : "CONNECT" /* Connect */);
-      if (this.#reconnect.connecting)
-        this.#reconnect.settle(new GatewayError(`Gateway closed before READY (code ${code}).`, code));
-      return;
-    }
-    if (action === "identify")
-      this.#session.invalidate(token, "session-timeout");
-    this.#setState("RECONNECT" /* Reconnect */);
-    this.#scheduleReconnect();
-  }
-  #scheduleReconnect() {
-    if (this.#closed)
-      return;
-    const result = this.#reconnect.schedule(() => this.#open(this.#session.connectURL(DEFAULT_GATEWAY_URL)));
-    if (result.scheduled) {
-      this.#reconnects++;
-      if (result.unstable)
-        this.#emit("unstable", {
-          reconnects: result.unstable.reconnects,
-          delay: result.delayMs
-        });
-      return;
-    }
-    if (result.reason !== "exhausted")
-      return;
-    this.#reconnect.settle(new GatewayError("Gateway reconnect attempts exhausted."));
-    this.#setState("CONNECT" /* Connect */);
-  }
-  #settleConnect(error) {
-    this.#reconnect.settle(error);
-  }
-  #clearTimers() {
-    clearTimeout(this.#connectTimer);
-    this.#reconnect.cancel();
-    this.#heartbeat.stop();
-  }
-  #normalizeError(error) {
-    return error instanceof GatewayError ? error : new GatewayError("Gateway connection failed.", undefined, {
-      cause: error
-    });
-  }
-  #emitError(error) {
-    this.#emit("error", error instanceof Error ? error : new GatewayError(String(error)));
-  }
-  #emit(event, data) {
-    this.#events.emit(event, data);
-  }
-  #setState(next) {
-    if (this.state === next)
-      return;
-    const previous = this.state;
-    this.state = next;
-    this.#emit("stateChange", { previous, next });
-  }
-}
+  GatewaySession2,
+  GatewayHeartbeat2,
+  GatewayCloseCodes2,
+  FATAL_CLOSE_CODES2,
+  IDENTIFY_CLOSE_CODES2,
+  classifyCloseCode2,
+  GatewayReconnect2,
+  PlainTextDecoder2,
+  ZlibStreamDecoder2,
+  createDecoder2,
+  WebSocketTransport2,
+  GatewayOpcodes2,
+  classifyFrame2,
+  classifyPayload2,
+  identifyPayload2,
+  resumePayload2,
+  heartbeatPayload2,
+  GatewayDispatcher2,
+  GatewaySendLimiter2,
+  GatewayState2,
+  GatewayError2,
+  Gateway2
+} from "../chunks/index-fdvgk2sw.js";
+import"../chunks/index-gyvps8b9.js";
 export {
-  FATAL_CLOSE_CODES,
-  Gateway,
-  GatewayCloseCodes,
-  GatewayDispatcher,
-  GatewayError,
-  GatewayHeartbeat,
-  GatewayOpcodes,
-  GatewayReconnect,
-  GatewaySendLimiter,
-  GatewaySession,
-  GatewayState,
-  IDENTIFY_CLOSE_CODES,
-  PlainTextDecoder,
-  SendBudget,
-  GatewayState as Status,
-  WebSocketTransport,
-  ZlibStreamDecoder,
-  classifyCloseCode,
-  classifyFrame,
-  classifyPayload,
-  createDecoder,
-  heartbeatPayload,
-  identifyPayload,
-  resumePayload
+  FATAL_CLOSE_CODES2 as FATAL_CLOSE_CODES,
+  Gateway2 as Gateway,
+  GatewayCloseCodes2 as GatewayCloseCodes,
+  GatewayDispatcher2 as GatewayDispatcher,
+  GatewayError2 as GatewayError,
+  GatewayHeartbeat2 as GatewayHeartbeat,
+  GatewayOpcodes2 as GatewayOpcodes,
+  GatewayReconnect2 as GatewayReconnect,
+  GatewaySendLimiter2 as GatewaySendLimiter,
+  GatewaySession2 as GatewaySession,
+  GatewayState2 as GatewayState,
+  IDENTIFY_CLOSE_CODES2 as IDENTIFY_CLOSE_CODES,
+  PlainTextDecoder2 as PlainTextDecoder,
+  WebSocketTransport2 as WebSocketTransport,
+  ZlibStreamDecoder2 as ZlibStreamDecoder,
+  classifyCloseCode2 as classifyCloseCode,
+  classifyFrame2 as classifyFrame,
+  classifyPayload2 as classifyPayload,
+  createDecoder2 as createDecoder,
+  heartbeatPayload2 as heartbeatPayload,
+  identifyPayload2 as identifyPayload,
+  resumePayload2 as resumePayload
 };
 
-//# debugId=49D265E85C1E654C64756E2164756E21
+//# debugId=64196C225A3F568164756E2164756E21