@ix-xs/twitch.api 1.0.5 → 2.0.0

package/dist/index.js

@@ -0,0 +1,3738 @@
+// src/api/base.ts
+var ApiGroup = class {
+  rest;
+  constructor(rest) {
+    this.rest = rest;
+  }
+};
+
+// src/api/ads.ts
+var AdsApi = class extends ApiGroup {
+  startCommercial(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "channels/commercial",
+      body: params,
+      scopes: ["channel:edit:commercial"],
+      context: { body: "broadcaster_id" },
+      options
+    });
+  }
+  schedule(params = {}, options) {
+    return this.rest.one({
+      path: "channels/ads",
+      query: params,
+      scopes: ["channel:read:ads"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  snooze(params = {}, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "channels/ads/schedule/snooze",
+      query: params,
+      scopes: ["channel:manage:ads"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/analytics.ts
+var AnalyticsApi = class extends ApiGroup {
+  extensions(params = {}, options) {
+    return this.rest.paginate({
+      path: "analytics/extensions",
+      query: params,
+      auth: "user",
+      scopes: ["analytics:read:extensions"],
+      options
+    });
+  }
+  games(params = {}, options) {
+    return this.rest.paginate({
+      path: "analytics/games",
+      query: params,
+      auth: "user",
+      scopes: ["analytics:read:games"],
+      options
+    });
+  }
+};
+
+// src/api/bits.ts
+var BitsApi = class extends ApiGroup {
+  async leaderboard(params = {}, options) {
+    const body = await this.rest.request({
+      path: "bits/leaderboard",
+      query: params,
+      auth: "user",
+      scopes: ["bits:read"],
+      options
+    });
+    return { data: body.data, date_range: body.date_range, total: body.total };
+  }
+  cheermotes(params = {}, options) {
+    return this.rest.data({ path: "bits/cheermotes", query: params, options });
+  }
+  customPowerUps(params = {}, options) {
+    return this.rest.chunked(
+      {
+        path: "bits/custom_power_ups",
+        query: params,
+        auth: "user",
+        scopes: ["bits:read"],
+        context: "broadcaster_id",
+        options
+      },
+      ["id"],
+      50
+    );
+  }
+  extensionTransactions(params, options) {
+    return this.rest.paginate({
+      path: "extensions/transactions",
+      query: params,
+      auth: "app",
+      options
+    });
+  }
+};
+
+// src/api/channels.ts
+var ChannelsApi = class extends ApiGroup {
+  get(params, options) {
+    return this.rest.chunked({ path: "channels", query: params, options }, ["broadcaster_id"]);
+  }
+  update(params = {}, options) {
+    const { broadcaster_id, ...body } = params;
+    return this.rest.send({
+      method: "PATCH",
+      path: "channels",
+      query: { broadcaster_id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:broadcast"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  editors(params = {}, options) {
+    return this.rest.data({
+      path: "channels/editors",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:editors"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  followed(params = {}, options) {
+    return this.rest.paginate({
+      path: "channels/followed",
+      query: params,
+      auth: "user",
+      scopes: ["user:read:follows"],
+      context: "user_id",
+      options
+    });
+  }
+  followers(params, options) {
+    return this.rest.paginate({ path: "channels/followers", query: params, prefer: "user", options });
+  }
+};
+
+// src/api/channel-points.ts
+var ChannelPointsApi = class extends ApiGroup {
+  createReward(params, options) {
+    const { broadcaster_id, ...body } = params;
+    return this.rest.one({
+      method: "POST",
+      path: "channel_points/custom_rewards",
+      query: { broadcaster_id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:redemptions"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  deleteReward(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "channel_points/custom_rewards",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:redemptions"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  rewards(params = {}, options) {
+    return this.rest.chunked(
+      {
+        path: "channel_points/custom_rewards",
+        query: params,
+        auth: "user",
+        scopes: ["channel:read:redemptions", "channel:manage:redemptions"],
+        context: "broadcaster_id",
+        options
+      },
+      ["id"],
+      50
+    );
+  }
+  redemptions(params, options) {
+    return this.rest.paginate(
+      {
+        path: "channel_points/custom_rewards/redemptions",
+        query: params,
+        auth: "user",
+        scopes: ["channel:read:redemptions", "channel:manage:redemptions"],
+        context: "broadcaster_id",
+        options
+      },
+      { max: 50 }
+    );
+  }
+  updateReward(params, options) {
+    const { broadcaster_id, id, ...body } = params;
+    return this.rest.one({
+      method: "PATCH",
+      path: "channel_points/custom_rewards",
+      query: { broadcaster_id, id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:redemptions"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  updateRedemptions(params, options) {
+    const { status, ...query } = params;
+    return this.rest.data({
+      method: "PATCH",
+      path: "channel_points/custom_rewards/redemptions",
+      query,
+      body: { status },
+      auth: "user",
+      scopes: ["channel:manage:redemptions"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/charity.ts
+var CharityApi = class extends ApiGroup {
+  campaign(params = {}, options) {
+    return this.rest.first({
+      path: "charity/campaigns",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:charity"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  donations(params = {}, options) {
+    return this.rest.paginate({
+      path: "charity/donations",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:charity"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/util.ts
+var Emitter = class {
+  #listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) this.#listeners.set(event, set = /* @__PURE__ */ new Set());
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const off = this.on(event, ((...args) => {
+      off();
+      listener(...args);
+    }));
+    return off;
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  emit(event, ...args) {
+    const set = this.#listeners.get(event);
+    if (!set || set.size === 0) return false;
+    for (const listener of [...set]) {
+      try {
+        listener(...args);
+      } catch (error) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+    }
+    return true;
+  }
+  has(event) {
+    return (this.#listeners.get(event)?.size ?? 0) > 0;
+  }
+  clear() {
+    this.#listeners.clear();
+  }
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function unref(timer) {
+  if (typeof timer === "number") globalThis.Deno?.unrefTimer?.(timer);
+  else timer.unref?.();
+  return timer;
+}
+function backoff(attempt, base = 250, max = 8e3) {
+  const ceiling = Math.min(max, base * 2 ** attempt);
+  return Math.round(ceiling / 2 + Math.random() * (ceiling / 2));
+}
+function fingerprint(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+function toArray(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? [...value] : [value];
+}
+var BoundedMap = class {
+  #map = /* @__PURE__ */ new Map();
+  #max;
+  constructor(max) {
+    this.#max = max;
+  }
+  get size() {
+    return this.#map.size;
+  }
+  has(key) {
+    return this.#map.has(key);
+  }
+  get(key) {
+    return this.#map.get(key);
+  }
+  set(key, value) {
+    if (this.#map.has(key)) this.#map.delete(key);
+    else if (this.#map.size >= this.#max) {
+      const oldest = this.#map.keys().next();
+      if (!oldest.done) this.#map.delete(oldest.value);
+    }
+    this.#map.set(key, value);
+  }
+  delete(key) {
+    return this.#map.delete(key);
+  }
+  clear() {
+    this.#map.clear();
+  }
+};
+
+// src/api/chat.ts
+var ChatApi = class extends ApiGroup {
+  chatters(params, options) {
+    return this.rest.paginate(
+      {
+        path: "chat/chatters",
+        query: params,
+        scopes: ["moderator:read:chatters"],
+        context: "moderator_id",
+        options
+      },
+      { max: 1e3 }
+    );
+  }
+  async channelEmotes(params, options) {
+    const { data, template } = await this.rest.request({
+      path: "chat/emotes",
+      query: params,
+      options
+    });
+    return { data, template };
+  }
+  async globalEmotes(options) {
+    const { data, template } = await this.rest.request({
+      path: "chat/emotes/global",
+      options
+    });
+    return { data, template };
+  }
+  async emoteSets(params, options) {
+    const ids = typeof params.emote_set_id === "string" ? [params.emote_set_id] : params.emote_set_id;
+    const bodies = await Promise.all(
+      chunk(ids, 25).map(
+        (emote_set_id) => this.rest.request({ path: "chat/emotes/set", query: { emote_set_id }, options })
+      )
+    );
+    return { data: bodies.flatMap((body) => body.data), template: bodies[0]?.template ?? "" };
+  }
+  channelBadges(params, options) {
+    return this.rest.data({ path: "chat/badges", query: params, options });
+  }
+  globalBadges(options) {
+    return this.rest.data({ path: "chat/badges/global", options });
+  }
+  settings(params, options) {
+    return this.rest.one({ path: "chat/settings", query: params, options });
+  }
+  sharedSession(params, options) {
+    return this.rest.first({ path: "shared_chat/session", query: params, options });
+  }
+  userEmotes(params = {}, options) {
+    return this.rest.paginate(
+      {
+        path: "chat/emotes/user",
+        query: params,
+        auth: "user",
+        scopes: ["user:read:emotes"],
+        context: "user_id",
+        options
+      },
+      // The endpoint has no page size parameter.
+      { sizeParam: null }
+    );
+  }
+  updateSettings(params, options) {
+    const { broadcaster_id, moderator_id, ...body } = params;
+    return this.rest.one({
+      method: "PATCH",
+      path: "chat/settings",
+      query: { broadcaster_id, moderator_id },
+      body,
+      scopes: ["moderator:manage:chat_settings"],
+      context: "moderator_id",
+      options
+    });
+  }
+  announce(params, options) {
+    const { broadcaster_id, moderator_id, ...body } = params;
+    return this.rest.send({
+      method: "POST",
+      path: "chat/announcements",
+      query: { broadcaster_id, moderator_id },
+      body,
+      scopes: ["moderator:manage:announcements"],
+      context: "moderator_id",
+      options
+    });
+  }
+  shoutout(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "chat/shoutouts",
+      query: params,
+      scopes: ["moderator:manage:shoutouts"],
+      context: "moderator_id",
+      options
+    });
+  }
+  send(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "chat/messages",
+      body: params,
+      scopes: ["user:write:chat"],
+      context: { body: "sender_id" },
+      options
+    });
+  }
+  pinnedMessage(params, options) {
+    return this.rest.first({
+      path: "chat/pins",
+      query: params,
+      scopes: ["moderator:manage:chat_messages", "moderator:read:chat_messages"],
+      context: "moderator_id",
+      options
+    });
+  }
+  pin(params, options) {
+    return this.rest.send({
+      method: "PUT",
+      path: "chat/pins",
+      query: params,
+      scopes: ["moderator:manage:chat_messages"],
+      context: "moderator_id",
+      options
+    });
+  }
+  updatePin(params, options) {
+    return this.rest.send({
+      method: "PATCH",
+      path: "chat/pins",
+      query: params,
+      scopes: ["moderator:manage:chat_messages"],
+      context: "moderator_id",
+      options
+    });
+  }
+  unpin(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "chat/pins",
+      query: params,
+      scopes: ["moderator:manage:chat_messages"],
+      context: "moderator_id",
+      options
+    });
+  }
+  colors(params, options) {
+    return this.rest.chunked({ path: "chat/color", query: params, options }, ["user_id"]);
+  }
+  setColor(params, options) {
+    return this.rest.send({
+      method: "PUT",
+      path: "chat/color",
+      query: params,
+      auth: "user",
+      scopes: ["user:manage:chat_color"],
+      context: "user_id",
+      options
+    });
+  }
+};
+
+// src/api/clips.ts
+var ClipsApi = class extends ApiGroup {
+  create(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "clips",
+      query: params,
+      auth: "user",
+      scopes: ["clips:edit"],
+      options
+    });
+  }
+  createFromVod(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "videos/clips",
+      query: params,
+      scopes: ["editor:manage:clips", "channel:manage:clips"],
+      context: "editor_id",
+      options
+    });
+  }
+  get(params, options) {
+    return this.rest.paginate({ path: "clips", query: params, options });
+  }
+  downloads(params, options) {
+    return this.rest.chunked(
+      {
+        path: "clips/downloads",
+        query: params,
+        scopes: ["editor:manage:clips", "channel:manage:clips"],
+        context: "editor_id",
+        options
+      },
+      ["clip_id"],
+      10
+    );
+  }
+};
+
+// src/api/conduits.ts
+var ConduitsApi = class extends ApiGroup {
+  list(options) {
+    return this.rest.data({ path: "eventsub/conduits", auth: "app", options });
+  }
+  create(params, options) {
+    return this.rest.one({ method: "POST", path: "eventsub/conduits", body: params, auth: "app", options });
+  }
+  update(params, options) {
+    return this.rest.one({ method: "PATCH", path: "eventsub/conduits", body: params, auth: "app", options });
+  }
+  delete(id, options) {
+    return this.rest.send({ method: "DELETE", path: "eventsub/conduits", query: { id }, auth: "app", options });
+  }
+  shards(params, options) {
+    return this.rest.paginate(
+      { path: "eventsub/conduits/shards", query: params, auth: "app", options },
+      // The endpoint has no page size parameter.
+      { sizeParam: null }
+    );
+  }
+  async updateShards(params, options) {
+    const result = { data: [], errors: [] };
+    for (let start = 0; start < params.shards.length; start += 100) {
+      const body = await this.rest.request({
+        method: "PATCH",
+        path: "eventsub/conduits/shards",
+        body: { conduit_id: params.conduit_id, shards: params.shards.slice(start, start + 100) },
+        auth: "app",
+        options
+      });
+      result.data.push(...body?.data ?? []);
+      result.errors.push(...body?.errors ?? []);
+    }
+    return result;
+  }
+};
+
+// src/api/content-labels.ts
+var ContentLabelsApi = class extends ApiGroup {
+  list(params = {}, options) {
+    return this.rest.data({ path: "content_classification_labels", query: params, options });
+  }
+};
+
+// src/api/entitlements.ts
+var EntitlementsApi = class extends ApiGroup {
+  drops(params = {}, options) {
+    return this.rest.paginate({ path: "entitlements/drops", query: params, options }, { max: 1e3 });
+  }
+  updateDrops(params = {}, options) {
+    return this.rest.data({
+      method: "PATCH",
+      path: "entitlements/drops",
+      body: params,
+      options
+    });
+  }
+};
+
+// src/api/extensions.ts
+var ExtensionsApi = class extends ApiGroup {
+  configuration(params, options) {
+    return this.rest.data({
+      path: "extensions/configurations",
+      query: params,
+      options
+    });
+  }
+  setConfiguration(params, options) {
+    return this.rest.send({
+      method: "PUT",
+      path: "extensions/configurations",
+      body: params,
+      options
+    });
+  }
+  setRequiredConfiguration(params, options) {
+    const { broadcaster_id, ...body } = params;
+    return this.rest.send({
+      method: "PUT",
+      path: "extensions/required_configuration",
+      query: { broadcaster_id },
+      body,
+      options
+    });
+  }
+  sendPubSub(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "extensions/pubsub",
+      body: params,
+      options
+    });
+  }
+  liveChannels(params, options) {
+    return this.rest.paginate({
+      path: "extensions/live",
+      query: params,
+      options
+    });
+  }
+  secrets(params, options) {
+    return this.rest.one({
+      path: "extensions/jwt/secrets",
+      query: params,
+      options
+    });
+  }
+  createSecret(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "extensions/jwt/secrets",
+      query: params,
+      options
+    });
+  }
+  sendChatMessage(params, options) {
+    const { broadcaster_id, ...body } = params;
+    return this.rest.send({
+      method: "POST",
+      path: "extensions/chat",
+      query: { broadcaster_id },
+      body,
+      options
+    });
+  }
+  get(params, options) {
+    return this.rest.first({
+      path: "extensions",
+      query: params,
+      options
+    });
+  }
+  released(params, options) {
+    return this.rest.one({
+      path: "extensions/released",
+      query: params,
+      options
+    });
+  }
+  bitsProducts(params = {}, options) {
+    return this.rest.data({
+      path: "bits/extensions",
+      query: params,
+      auth: "app",
+      options
+    });
+  }
+  updateBitsProduct(params, options) {
+    return this.rest.one({
+      method: "PUT",
+      path: "bits/extensions",
+      body: params,
+      auth: "app",
+      options
+    });
+  }
+};
+
+// src/errors.ts
+var TwitchError = class extends Error {
+  name = "TwitchError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var TwitchApiError = class extends TwitchError {
+  name = "TwitchApiError";
+  status;
+  method;
+  url;
+  error;
+  body;
+  headers;
+  constructor(message, info) {
+    super(message);
+    this.status = info.status;
+    this.method = info.method;
+    this.url = info.url;
+    this.error = info.error;
+    this.body = info.body;
+    this.headers = info.headers;
+  }
+};
+var TwitchRateLimitError = class extends TwitchApiError {
+  name = "TwitchRateLimitError";
+  resetAt;
+  constructor(message, info, resetAt) {
+    super(message, info);
+    this.resetAt = resetAt;
+  }
+  get retryAfter() {
+    return this.resetAt === void 0 ? 0 : Math.max(0, this.resetAt - Date.now());
+  }
+};
+var TwitchAuthError = class extends TwitchError {
+  name = "TwitchAuthError";
+  userId;
+  constructor(message, options) {
+    super(message, options);
+    this.userId = options?.userId;
+  }
+};
+var TwitchScopeError = class extends TwitchAuthError {
+  name = "TwitchScopeError";
+  required;
+  granted;
+  constructor(userId, required, granted, what) {
+    const list = required.map((s) => `"${s}"`).join(" or ");
+    super(`The token of user ${userId} is missing the ${list} scope required by ${what}.`, { userId });
+    this.required = required;
+    this.granted = granted;
+  }
+};
+var TwitchNetworkError = class extends TwitchError {
+  name = "TwitchNetworkError";
+};
+var TwitchTimeoutError = class extends TwitchError {
+  name = "TwitchTimeoutError";
+};
+var TwitchEventSubError = class extends TwitchError {
+  name = "TwitchEventSubError";
+};
+
+// src/eventsub/types/activity.ts
+var activityVersions = {
+  "channel.guest_star_session.begin": "beta",
+  "channel.guest_star_session.end": "beta",
+  "channel.guest_star_guest.update": "beta",
+  "channel.guest_star_settings.update": "beta",
+  "channel.channel_points_automatic_reward_redemption.add": "2",
+  "channel.channel_points_automatic_reward_redemption.add@1": "1",
+  "channel.channel_points_custom_reward.add": "1",
+  "channel.channel_points_custom_reward.update": "1",
+  "channel.channel_points_custom_reward.remove": "1",
+  "channel.channel_points_custom_reward_redemption.add": "1",
+  "channel.channel_points_custom_reward_redemption.update": "1",
+  "channel.custom_power_up_redemption.add": "1",
+  "channel.poll.begin": "1",
+  "channel.poll.progress": "1",
+  "channel.poll.end": "1",
+  "channel.prediction.begin": "1",
+  "channel.prediction.progress": "1",
+  "channel.prediction.lock": "1",
+  "channel.prediction.end": "1",
+  "channel.charity_campaign.donate": "1",
+  "channel.charity_campaign.start": "1",
+  "channel.charity_campaign.progress": "1",
+  "channel.charity_campaign.stop": "1",
+  "conduit.shard.disabled": "1",
+  "drop.entitlement.grant": "1",
+  "extension.bits_transaction.create": "1",
+  "channel.goal.begin": "1",
+  "channel.goal.progress": "1",
+  "channel.goal.end": "1",
+  "channel.hype_train.begin": "2",
+  "channel.hype_train.progress": "2",
+  "channel.hype_train.end": "2",
+  "user.authorization.grant": "1",
+  "user.authorization.revoke": "1",
+  "user.update": "1",
+  "user.whisper.message": "1"
+};
+
+// src/eventsub/types/channel.ts
+var channelVersions = {
+  "channel.update": "2",
+  "channel.follow": "2",
+  "channel.ad_break.begin": "1",
+  "channel.subscribe": "1",
+  "channel.subscription.end": "1",
+  "channel.subscription.gift": "1",
+  "channel.subscription.message": "1",
+  "channel.cheer": "1",
+  "channel.raid": "1",
+  "channel.ban": "1",
+  "channel.unban": "1",
+  "channel.unban_request.create": "1",
+  "channel.unban_request.resolve": "1",
+  "channel.moderate": "2",
+  "channel.moderate@1": "1",
+  "channel.moderator.add": "1",
+  "channel.moderator.remove": "1",
+  "channel.suspicious_user.message": "1",
+  "channel.suspicious_user.update": "1",
+  "channel.vip.add": "1",
+  "channel.vip.remove": "1",
+  "channel.warning.acknowledge": "1",
+  "channel.warning.send": "1",
+  "channel.shield_mode.begin": "1",
+  "channel.shield_mode.end": "1",
+  "channel.shoutout.create": "1",
+  "channel.shoutout.receive": "1",
+  "stream.online": "1",
+  "stream.offline": "1"
+};
+
+// src/eventsub/types/chat.ts
+var chatVersions = {
+  "automod.message.hold": "2",
+  "automod.message.hold@1": "1",
+  "automod.message.update": "2",
+  "automod.message.update@1": "1",
+  "automod.settings.update": "1",
+  "automod.terms.update": "1",
+  "channel.bits.use": "1",
+  "channel.chat.clear": "1",
+  "channel.chat.clear_user_messages": "1",
+  "channel.chat.message": "1",
+  "channel.chat.message_delete": "1",
+  "channel.chat.notification": "1",
+  "channel.chat_settings.update": "1",
+  "channel.chat.user_message_hold": "1",
+  "channel.chat.user_message_update": "1",
+  "channel.shared_chat.begin": "1",
+  "channel.shared_chat.update": "1",
+  "channel.shared_chat.end": "1"
+};
+
+// src/eventsub/types/index.ts
+var EVENTSUB_VERSIONS = {
+  ...activityVersions,
+  ...channelVersions,
+  ...chatVersions
+};
+function resolveEventSubType(key) {
+  const at = key.lastIndexOf("@");
+  if (at > 0) return { type: key.slice(0, at), version: key.slice(at + 1) };
+  const version = EVENTSUB_VERSIONS[key];
+  if (version === void 0) {
+    throw new TwitchEventSubError(`Unknown EventSub type "${key}". For a type newer than this library, write "${key}@<version>".`);
+  }
+  return { type: key, version };
+}
+
+// src/eventsub/listener.ts
+function subscriptionKey(type, version, condition) {
+  const fields = Object.entries(condition).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([name, value]) => `${name}=${String(value)}`).sort();
+  return `${type}@${version}?${fields.join("&")}`;
+}
+var EventSubListener = class {
+  entries = /* @__PURE__ */ new Map();
+  #byId = /* @__PURE__ */ new Map();
+  #events = new Emitter();
+  on(type, condition, handler) {
+    const resolved = resolveEventSubType(type);
+    const cleaned = {};
+    for (const [name, value] of Object.entries(condition)) {
+      if (value !== void 0 && value !== null) cleaned[name] = String(value);
+    }
+    const key = subscriptionKey(resolved.type, resolved.version, cleaned);
+    const callback = handler;
+    let entry = this.entries.get(key);
+    if (entry) {
+      entry.handlers.add(callback);
+    } else {
+      let settle;
+      const ready = new Promise((resolve, reject) => settle = { resolve, reject });
+      ready.catch(() => {
+      });
+      entry = {
+        key,
+        type: resolved.type,
+        version: resolved.version,
+        condition: cleaned,
+        handlers: /* @__PURE__ */ new Set([callback]),
+        subscription: void 0,
+        ready,
+        settle,
+        settled: false
+      };
+      this.entries.set(key, entry);
+      const created = entry;
+      this.attach(created).catch((error) => this.reject(created, error));
+    }
+    const target = entry;
+    return {
+      type: target.type,
+      version: target.version,
+      condition: target.condition,
+      ready: target.ready,
+      stop: async () => {
+        target.handlers.delete(callback);
+        if (target.handlers.size > 0 || this.entries.get(target.key) !== target) return;
+        this.forget(target);
+        await this.detach(target);
+      }
+    };
+  }
+  onError(listener) {
+    return this.#events.on("error", listener);
+  }
+  onRevocation(listener) {
+    return this.#events.on("revocation", listener);
+  }
+  get size() {
+    return this.entries.size;
+  }
+  accept(entry, subscription) {
+    if (subscription) {
+      if (entry.subscription) this.#byId.delete(entry.subscription.id);
+      entry.subscription = subscription;
+      this.#byId.set(subscription.id, entry);
+    }
+    if (!entry.settled) {
+      entry.settled = true;
+      entry.settle.resolve();
+    }
+  }
+  reject(entry, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    const error = new TwitchEventSubError(`Could not subscribe to ${entry.type} (version ${entry.version}): ${reason}`, {
+      cause
+    });
+    this.expire(entry, error);
+    this.forget(entry);
+  }
+  expire(entry, error) {
+    if (!entry.settled) {
+      entry.settled = true;
+      entry.settle.reject(error);
+    }
+    this.fail(error);
+  }
+  active(entry) {
+    return this.entries.get(entry.key) === entry;
+  }
+  forget(entry) {
+    if (this.entries.get(entry.key) === entry) this.entries.delete(entry.key);
+    if (entry.subscription) this.#byId.delete(entry.subscription.id);
+    if (!entry.settled) {
+      entry.settled = true;
+      entry.settle.reject(
+        new TwitchEventSubError(`The subscription to ${entry.type} was removed before Twitch confirmed it.`)
+      );
+    }
+  }
+  find(subscription) {
+    return this.#byId.get(subscription.id) ?? this.entries.get(subscriptionKey(subscription.type, subscription.version, subscription.condition ?? {}));
+  }
+  dispatch(subscription, event, meta) {
+    const entry = this.find(subscription);
+    if (!entry) return Promise.resolve();
+    if (!entry.subscription) this.accept(entry, subscription);
+    const full = { ...meta, type: subscription.type, version: subscription.version, subscription };
+    const running = [];
+    for (const handler of [...entry.handlers]) {
+      try {
+        const result = handler(event, full);
+        if (result && typeof result.then === "function") {
+          running.push(result.then(void 0, (error) => this.fail(error)));
+        }
+      } catch (error) {
+        this.fail(error);
+      }
+    }
+    return Promise.all(running).then(() => void 0);
+  }
+  revoked(subscription) {
+    const entry = this.find(subscription);
+    if (entry) this.forget(entry);
+    this.#events.emit("revocation", subscription);
+  }
+  fail(cause) {
+    const error = cause instanceof Error ? cause : new TwitchEventSubError(String(cause));
+    if (!this.#events.emit("error", error)) {
+      console.error("[twitch.api] EventSub error (add an onError listener to handle it yourself):", error);
+    }
+  }
+};
+
+// src/eventsub/webhook.ts
+var encoder = new TextEncoder();
+var VERIFICATION_TIMEOUT = 6e4;
+var MAX_REMEMBERED = 5e5;
+async function verifyEventSubSignature(input) {
+  const { secret, messageId, timestamp, signature, body } = input;
+  if (!messageId || !timestamp || !signature) return false;
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign"
+  ]);
+  const digest = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(messageId + timestamp + body)));
+  let expected = "sha256=";
+  for (const byte of digest) expected += byte.toString(16).padStart(2, "0");
+  const given = signature.toLowerCase();
+  let diff = expected.length ^ given.length;
+  for (let i = 0; i < expected.length; i++) diff |= expected.charCodeAt(i) ^ (given.charCodeAt(i) || 0);
+  return diff === 0;
+}
+var EventSubWebhook = class extends EventSubListener {
+  #backend;
+  #callback;
+  #secret;
+  #subscribe;
+  #maxAge;
+  #seen = /* @__PURE__ */ new Map();
+  constructor(backend, options) {
+    super();
+    if (!options?.callback || !options.secret) {
+      throw new TwitchEventSubError("A webhook listener needs a `callback` URL and a `secret`.");
+    }
+    if (options.secret.length < 10 || options.secret.length > 100) {
+      throw new TwitchEventSubError("The webhook secret must be 10 to 100 characters long.");
+    }
+    this.#backend = backend;
+    this.#callback = options.callback;
+    this.#secret = options.secret;
+    this.#subscribe = options.subscribe ?? true;
+    this.#maxAge = (options.maxAge ?? 600) * 1e3;
+  }
+  async handle(request, context) {
+    const result = await this.process({ header: (name) => request.headers.get(name), body: await request.text() }, context);
+    return new Response(result.body ?? null, {
+      status: result.status,
+      headers: result.body === void 0 ? {} : { "Content-Type": "text/plain" }
+    });
+  }
+  nodeHandler() {
+    return async (req, res) => {
+      let result;
+      try {
+        const body = await readNodeBody(req);
+        result = await this.process({
+          header: (name) => {
+            const value = req.headers[name.toLowerCase()];
+            return Array.isArray(value) ? value[0] : value;
+          },
+          body
+        });
+      } catch (error) {
+        this.fail(error);
+        result = { status: 500 };
+      }
+      if (result.body === void 0) res.writeHead(result.status);
+      else res.writeHead(result.status, { "Content-Type": "text/plain" });
+      res.end(result.body);
+    };
+  }
+  async process(request, context) {
+    const messageId = request.header("Twitch-Eventsub-Message-Id");
+    const timestamp = request.header("Twitch-Eventsub-Message-Timestamp");
+    const signature = request.header("Twitch-Eventsub-Message-Signature");
+    const messageType = request.header("Twitch-Eventsub-Message-Type");
+    if (!messageId || !timestamp || !signature || !messageType) return { status: 400 };
+    const now = Date.now();
+    const sentAt = Date.parse(timestamp);
+    if (Number.isNaN(sentAt) || Math.abs(now - sentAt) > this.#maxAge) return { status: 403 };
+    const valid = await verifyEventSubSignature({ secret: this.#secret, messageId, timestamp, signature, body: request.body });
+    if (!valid) return { status: 403 };
+    let payload;
+    try {
+      payload = JSON.parse(request.body);
+    } catch {
+      return { status: 400 };
+    }
+    if (typeof payload !== "object" || payload === null || typeof payload.subscription !== "object" || payload.subscription === null) {
+      return { status: 400 };
+    }
+    if (messageType === "webhook_callback_verification") {
+      const entry = this.find(payload.subscription);
+      if (entry) this.accept(entry, payload.subscription);
+      return { status: 200, body: payload.challenge ?? "" };
+    }
+    if (this.#remember(messageId, now)) return { status: 204 };
+    if (messageType === "notification") {
+      const work = this.dispatch(payload.subscription, payload.event ?? payload.events, { messageId, timestamp });
+      context?.waitUntil?.(work);
+    } else if (messageType === "revocation") {
+      this.revoked(payload.subscription);
+    }
+    return { status: 204 };
+  }
+  async attach(entry) {
+    if (!this.#subscribe) {
+      this.accept(entry);
+      return;
+    }
+    let subscription;
+    try {
+      subscription = await this.#backend.create({
+        type: entry.type,
+        version: entry.version,
+        condition: entry.condition,
+        transport: { method: "webhook", callback: this.#callback, secret: this.#secret }
+      });
+    } catch (error) {
+      if (error instanceof TwitchApiError && error.status === 409) return this.accept(entry);
+      throw error;
+    }
+    if (!this.active(entry)) {
+      await this.#backend.remove(subscription.id, "app").catch(() => {
+      });
+      return;
+    }
+    if (subscription.status === "enabled") {
+      this.accept(entry, subscription);
+      return;
+    }
+    entry.subscription = subscription;
+    unref(
+      setTimeout(() => {
+        if (entry.settled || !this.active(entry)) return;
+        this.expire(
+          entry,
+          new TwitchEventSubError(
+            `Twitch did not verify the callback for ${entry.type} within ${VERIFICATION_TIMEOUT / 1e3} seconds. Check that ${this.#callback} is public, uses HTTPS on port 443 and reaches this listener.`
+          )
+        );
+      }, VERIFICATION_TIMEOUT)
+    );
+  }
+  async detach(entry) {
+    if (!this.#subscribe || !entry.subscription) return;
+    await this.#backend.remove(entry.subscription.id, "app").catch((error) => {
+      if (!(error instanceof TwitchApiError) || error.status !== 404) throw error;
+    });
+  }
+  #remember(messageId, now) {
+    for (const [id, seenAt] of this.#seen) {
+      if (now - seenAt <= this.#maxAge && this.#seen.size <= MAX_REMEMBERED) break;
+      this.#seen.delete(id);
+    }
+    if (this.#seen.has(messageId)) return true;
+    this.#seen.set(messageId, now);
+    return false;
+  }
+};
+async function readNodeBody(req) {
+  const parsed = req.body;
+  if (typeof parsed === "string") return parsed;
+  if (parsed instanceof Uint8Array) return new TextDecoder().decode(parsed);
+  if (parsed !== void 0 && parsed !== null && typeof parsed === "object" && Object.keys(parsed).length > 0) {
+    throw new TwitchEventSubError(
+      "The request body was already parsed by a middleware, so its signature cannot be verified. Mount the EventSub handler before JSON body parsers, or use a raw body parser on its route."
+    );
+  }
+  const chunks = [];
+  let length = 0;
+  for await (const chunk2 of req) {
+    const bytes = typeof chunk2 === "string" ? encoder.encode(chunk2) : chunk2;
+    chunks.push(bytes);
+    length += bytes.length;
+  }
+  const all = new Uint8Array(length);
+  let offset = 0;
+  for (const bytes of chunks) {
+    all.set(bytes, offset);
+    offset += bytes.length;
+  }
+  return new TextDecoder().decode(all);
+}
+
+// src/eventsub/websocket.ts
+var DEFAULT_URL = "wss://eventsub.wss.twitch.tv/ws";
+var KEEPALIVE_GRACE = 5e3;
+var SUBSCRIBE_BATCH = 20;
+var SUBSCRIBE_ATTEMPTS = 6;
+var Connection = class {
+  entries = /* @__PURE__ */ new Set();
+  sessionId;
+  ready = false;
+  #socket;
+  #pending;
+  #watchdog;
+  #retry;
+  #keepaliveMs = 1e4;
+  #attempts = 0;
+  #closed = false;
+  #opened = false;
+  #owner;
+  constructor(owner) {
+    this.#owner = owner;
+  }
+  ensureOpen() {
+    if (this.#opened || this.#closed) return;
+    this.#opened = true;
+    this.#open(this.#owner.url, false);
+  }
+  close() {
+    this.#closed = true;
+    this.sessionId = void 0;
+    this.ready = false;
+    clearTimeout(this.#watchdog);
+    clearTimeout(this.#retry);
+    for (const socket of [this.#socket, this.#pending]) if (socket) this.#release(socket);
+    this.#socket = this.#pending = void 0;
+  }
+  #open(url, handover) {
+    let socket;
+    try {
+      socket = new this.#owner.WebSocket(url);
+    } catch (error) {
+      this.#owner.report(new TwitchEventSubError(`Could not open the EventSub WebSocket: ${error.message}`, { cause: error }));
+      this.#scheduleReconnect();
+      return;
+    }
+    if (handover) this.#pending = socket;
+    else this.#socket = socket;
+    socket.onmessage = (event) => this.#message(socket, event.data);
+    socket.onclose = (event) => this.#lost(socket, event?.code, event?.reason);
+    socket.onerror = () => {
+    };
+    if (!handover) this.#arm(15e3);
+  }
+  #release(socket) {
+    socket.onmessage = socket.onclose = socket.onerror = socket.onopen = null;
+    try {
+      socket.close();
+    } catch {
+    }
+  }
+  #arm(ms = this.#keepaliveMs + KEEPALIVE_GRACE) {
+    clearTimeout(this.#watchdog);
+    this.#watchdog = unref(
+      setTimeout(() => {
+        const socket = this.#socket;
+        if (socket) this.#lost(socket, void 0, "keepalive timeout");
+      }, ms)
+    );
+  }
+  #message(socket, data) {
+    let frame;
+    try {
+      frame = JSON.parse(typeof data === "string" ? data : String(data));
+    } catch {
+      return;
+    }
+    const { metadata, payload } = frame;
+    switch (metadata?.message_type) {
+      case "session_welcome": {
+        const session = payload.session;
+        this.#keepaliveMs = (session.keepalive_timeout_seconds ?? 10) * 1e3;
+        this.#attempts = 0;
+        if (socket === this.#pending) {
+          const old = this.#socket;
+          this.#socket = socket;
+          this.#pending = void 0;
+          this.sessionId = session.id;
+          if (old) this.#release(old);
+          this.#arm();
+          this.#owner.handedOver(this, session.id);
+          return;
+        }
+        this.sessionId = session.id;
+        this.#arm();
+        this.#owner.established(this, session.id);
+        return;
+      }
+      case "session_keepalive":
+        if (socket === this.#socket) this.#arm();
+        return;
+      case "notification":
+        if (socket === this.#socket) this.#arm();
+        if (payload.subscription) this.#owner.notify(metadata, payload.subscription, payload.event ?? payload.events);
+        return;
+      case "session_reconnect":
+        if (payload.session?.reconnect_url && !this.#pending) this.#open(payload.session.reconnect_url, true);
+        return;
+      case "revocation":
+        if (socket === this.#socket) this.#arm();
+        if (payload.subscription) this.#owner.revoke(this, payload.subscription);
+        return;
+    }
+  }
+  #lost(socket, code, reason) {
+    if (this.#closed) return;
+    if (socket === this.#pending) {
+      this.#pending = void 0;
+      this.#release(socket);
+      return;
+    }
+    if (socket !== this.#socket) return;
+    clearTimeout(this.#watchdog);
+    this.#release(socket);
+    if (this.#pending) this.#release(this.#pending);
+    this.#socket = this.#pending = void 0;
+    this.sessionId = void 0;
+    this.ready = false;
+    const willReconnect = this.entries.size > 0;
+    this.#owner.dropped(this, { code, reason, willReconnect });
+    if (willReconnect) this.#scheduleReconnect();
+    else this.#opened = false;
+  }
+  #scheduleReconnect() {
+    if (this.#closed) return;
+    const delay = backoff(this.#attempts++, 500, 3e4);
+    this.#retry = setTimeout(() => {
+      if (!this.#closed) this.#open(this.#owner.url, false);
+    }, delay);
+  }
+};
+var EventSubWebSocket = class extends EventSubListener {
+  url;
+  WebSocket;
+  #backend;
+  #strategy;
+  #connections = [];
+  #where = /* @__PURE__ */ new Map();
+  #seen = new BoundedMap(1e3);
+  #lifecycle = new Emitter();
+  constructor(backend, strategy, options = {}) {
+    super();
+    const WebSocketClass = options.webSocket ?? globalThis.WebSocket;
+    if (!WebSocketClass) {
+      throw new TwitchEventSubError(
+        "This runtime has no global WebSocket. Pass one with the `webSocket` option (for example the `ws` package)."
+      );
+    }
+    this.WebSocket = WebSocketClass;
+    const url = new URL(options.url ?? DEFAULT_URL);
+    if (options.keepalive !== void 0) url.searchParams.set("keepalive_timeout_seconds", String(options.keepalive));
+    this.url = url.toString();
+    this.#backend = backend;
+    this.#strategy = strategy;
+  }
+  get sessionIds() {
+    return this.#connections.flatMap((connection) => connection.sessionId ? [connection.sessionId] : []);
+  }
+  get connected() {
+    return this.sessionIds.length > 0;
+  }
+  onConnect(listener) {
+    return this.#lifecycle.on("connect", (sessionId) => this.#guard(() => listener(sessionId)));
+  }
+  onDisconnect(listener) {
+    return this.#lifecycle.on("disconnect", (info) => this.#guard(() => listener(info)));
+  }
+  #guard(run) {
+    try {
+      const result = run();
+      if (result && typeof result.then === "function") {
+        result.then(void 0, (error) => this.fail(error));
+      }
+    } catch (error) {
+      this.fail(error);
+    }
+  }
+  close() {
+    for (const connection of this.#connections) connection.close();
+    this.#connections.length = 0;
+    this.#where.clear();
+    for (const entry of [...this.entries.values()]) this.forget(entry);
+  }
+  async attach(entry) {
+    let connection = this.#connections.find((candidate) => candidate.entries.size < this.#strategy.capacity);
+    if (!connection) {
+      if (this.#connections.length >= this.#strategy.maxSockets) {
+        throw new TwitchEventSubError(
+          `Subscription limit reached: ${this.#strategy.maxSockets} connections of ${this.#strategy.capacity} subscriptions.`
+        );
+      }
+      connection = new Connection(this);
+      this.#connections.push(connection);
+    }
+    connection.entries.add(entry);
+    this.#where.set(entry, connection);
+    if (connection.ready && connection.sessionId) await this.#subscribe(entry, connection, connection.sessionId);
+    else connection.ensureOpen();
+  }
+  async detach(entry) {
+    const connection = this.#where.get(entry);
+    this.#where.delete(entry);
+    if (!connection) return;
+    connection.entries.delete(entry);
+    const subscription = entry.subscription;
+    const alive = connection.sessionId !== void 0;
+    if (connection.entries.size === 0) {
+      connection.close();
+      this.#connections.splice(this.#connections.indexOf(connection), 1);
+    }
+    if (subscription && (alive || this.#strategy.persistent)) {
+      await this.#backend.remove(subscription.id, this.#strategy.auth, this.#strategy.options).catch((error) => {
+        if (!(error instanceof TwitchApiError) || error.status !== 404) throw error;
+      });
+    }
+  }
+  async #subscribe(entry, connection, sessionId) {
+    const current = () => this.#where.get(entry) === connection && connection.sessionId === sessionId;
+    for (let attempt = 0; current(); attempt++) {
+      try {
+        const subscription = await this.#backend.create(
+          {
+            type: entry.type,
+            version: entry.version,
+            condition: entry.condition,
+            transport: this.#strategy.transport(sessionId)
+          },
+          this.#strategy.options
+        );
+        if (this.#where.get(entry) !== connection) {
+          await this.#backend.remove(subscription.id, this.#strategy.auth, this.#strategy.options).catch(() => {
+          });
+          return;
+        }
+        this.accept(entry, subscription);
+        return;
+      } catch (error) {
+        if (!current()) return;
+        if (error instanceof TwitchApiError && error.status === 409 && this.#strategy.persistent) {
+          this.accept(entry);
+          return;
+        }
+        if (error instanceof TwitchApiError && error.status === 400 && /session/i.test(error.message)) return;
+        if (!isTemporary(error) || attempt + 1 >= SUBSCRIBE_ATTEMPTS) {
+          connection.entries.delete(entry);
+          this.#where.delete(entry);
+          if (connection.ready) this.#retire(connection);
+          throw error;
+        }
+        await sleep(backoff(attempt, 500, 3e4));
+      }
+    }
+  }
+  established(connection, sessionId) {
+    void (async () => {
+      for (let attempt = 0; ; attempt++) {
+        try {
+          await this.#strategy.onSession?.(sessionId);
+          break;
+        } catch (error) {
+          if (connection.sessionId !== sessionId) return;
+          const problem = new TwitchEventSubError(`Could not bind the WebSocket session: ${error.message}`, {
+            cause: error
+          });
+          if (!isTemporary(error)) {
+            const waiting = [...connection.entries].filter((entry) => !entry.settled);
+            if (waiting.length === 0) this.fail(problem);
+            for (const entry of waiting) {
+              connection.entries.delete(entry);
+              this.#where.delete(entry);
+              this.reject(entry, problem);
+            }
+            this.#retire(connection);
+            return;
+          }
+          if (attempt === 0) this.fail(problem);
+          await sleep(backoff(attempt, 500, 3e4));
+        }
+      }
+      if (connection.sessionId !== sessionId) return;
+      const pending = [...connection.entries].filter((entry) => !(this.#strategy.persistent && entry.settled));
+      connection.ready = true;
+      this.#lifecycle.emit("connect", sessionId);
+      for (let start = 0; start < pending.length; start += SUBSCRIBE_BATCH) {
+        if (connection.sessionId !== sessionId) return;
+        await Promise.all(
+          pending.slice(start, start + SUBSCRIBE_BATCH).map(
+            (entry) => this.#subscribe(entry, connection, sessionId).catch((error) => this.reject(entry, error))
+          )
+        );
+      }
+      this.#retire(connection);
+    })();
+  }
+  #retire(connection) {
+    if (connection.entries.size > 0) return;
+    connection.close();
+    const index = this.#connections.indexOf(connection);
+    if (index >= 0) this.#connections.splice(index, 1);
+  }
+  handedOver(_connection, sessionId) {
+    void (async () => {
+      try {
+        await this.#strategy.onSession?.(sessionId);
+      } catch (error) {
+        this.fail(error);
+      }
+      this.#lifecycle.emit("connect", sessionId);
+    })();
+  }
+  dropped(connection, info) {
+    this.#lifecycle.emit("disconnect", info);
+    if (!info.willReconnect) {
+      const index = this.#connections.indexOf(connection);
+      if (index >= 0 && connection.entries.size === 0) this.#connections.splice(index, 1);
+    }
+  }
+  notify(metadata, subscription, event) {
+    if (this.#seen.has(metadata.message_id)) return;
+    this.#seen.set(metadata.message_id, true);
+    void this.dispatch(subscription, event, { messageId: metadata.message_id, timestamp: metadata.message_timestamp });
+  }
+  revoke(connection, subscription) {
+    const entry = this.find(subscription);
+    if (entry) {
+      connection.entries.delete(entry);
+      this.#where.delete(entry);
+    }
+    this.revoked(subscription);
+  }
+  report(error) {
+    this.fail(error);
+  }
+};
+function isTemporary(error) {
+  if (error instanceof TwitchApiError) return error.status >= 500 || error.status === 429;
+  return error instanceof TwitchNetworkError || error instanceof TwitchTimeoutError;
+}
+
+// src/api/eventsub.ts
+function subscriptionBody(body) {
+  return body.type === "drop.entitlement.grant" ? { ...body, is_batching_enabled: true } : body;
+}
+var EventSubApi = class extends ApiGroup {
+  subscribe(params, options) {
+    const { type, version } = resolveEventSubType(params.type);
+    return this.rest.one({
+      method: "POST",
+      path: "eventsub/subscriptions",
+      body: subscriptionBody({ type, version, condition: params.condition, transport: params.transport }),
+      auth: params.transport.method === "websocket" ? "user" : "app",
+      options
+    });
+  }
+  unsubscribe(id, options) {
+    return this.rest.send({ method: "DELETE", path: "eventsub/subscriptions", query: { id }, options });
+  }
+  subscriptions(params = {}, options) {
+    return this.rest.paginate(
+      { path: "eventsub/subscriptions", query: params, options },
+      { sizeParam: null }
+    );
+  }
+  websocket(options = {}) {
+    const requestOptions = options.user ? { as: options.user } : {};
+    return this.#track(new EventSubWebSocket(
+      this.#backend(),
+      {
+        capacity: 300,
+        maxSockets: 3,
+        persistent: false,
+        auth: "user",
+        options: requestOptions,
+        transport: (sessionId) => ({ method: "websocket", session_id: sessionId })
+      },
+      options
+    ));
+  }
+  webhook(options) {
+    return new EventSubWebhook(this.#backend(), options);
+  }
+  conduit(options = {}) {
+    const shardId = options.shardId ?? "0";
+    let conduitId;
+    const resolveConduit = () => conduitId ??= (async () => {
+      if (options.conduitId) return options.conduitId;
+      const existing = await this.rest.data({ path: "eventsub/conduits", auth: "app" });
+      if (existing[0]) return existing[0].id;
+      const created = await this.rest.one({
+        method: "POST",
+        path: "eventsub/conduits",
+        body: { shard_count: Number(shardId) + 1 },
+        auth: "app"
+      });
+      return created.id;
+    })().catch((error) => {
+      conduitId = void 0;
+      throw error;
+    });
+    let boundTo;
+    return this.#track(new EventSubWebSocket(
+      this.#backend(),
+      {
+        capacity: Infinity,
+        maxSockets: 1,
+        persistent: true,
+        auth: "app",
+        options: {},
+        transport: () => {
+          if (!boundTo) throw new TwitchEventSubError("The conduit is not bound to a session yet.");
+          return { method: "conduit", conduit_id: boundTo };
+        },
+        onSession: async (sessionId) => {
+          const id = await resolveConduit();
+          const body = await this.rest.request({
+            method: "PATCH",
+            path: "eventsub/conduits/shards",
+            body: {
+              conduit_id: id,
+              shards: [{ id: shardId, transport: { method: "websocket", session_id: sessionId } }]
+            },
+            auth: "app"
+          });
+          const failure = body?.errors?.[0];
+          if (failure) throw new TwitchEventSubError(`Shard ${shardId} of conduit ${id}: ${failure.message}`);
+          boundTo = id;
+        }
+      },
+      options
+    ));
+  }
+  #track(listener) {
+    this.rest.onClose(() => listener.close());
+    return listener;
+  }
+  #backend() {
+    return {
+      create: (params, options) => this.rest.one({
+        method: "POST",
+        path: "eventsub/subscriptions",
+        body: subscriptionBody(params),
+        auth: params.transport.method === "websocket" ? "user" : "app",
+        options
+      }),
+      remove: (id, auth, options) => this.rest.send({ method: "DELETE", path: "eventsub/subscriptions", query: { id }, auth, options })
+    };
+  }
+};
+
+// src/api/games.ts
+var GamesApi = class extends ApiGroup {
+  top(params = {}, options) {
+    return this.rest.paginate({ path: "games/top", query: params, options });
+  }
+  get(params, options) {
+    return this.rest.chunked({ path: "games", query: params, options }, ["id", "name", "igdb_id"]);
+  }
+};
+
+// src/api/goals.ts
+var GoalsApi = class extends ApiGroup {
+  get(params = {}, options) {
+    return this.rest.data({
+      path: "goals",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:goals"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/guest-star.ts
+var GuestStarApi = class extends ApiGroup {
+  settings(params, options) {
+    return this.rest.one({
+      path: "guest_star/channel_settings",
+      query: params,
+      auth: "user",
+      scopes: [
+        "channel:read:guest_star",
+        "channel:manage:guest_star",
+        "moderator:read:guest_star",
+        "moderator:manage:guest_star"
+      ],
+      context: "moderator_id",
+      options
+    });
+  }
+  updateSettings(params = {}, options) {
+    const { broadcaster_id, ...body } = params;
+    return this.rest.send({
+      method: "PUT",
+      path: "guest_star/channel_settings",
+      query: { broadcaster_id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:guest_star"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  session(params, options) {
+    return this.rest.first({
+      path: "guest_star/session",
+      query: params,
+      auth: "user",
+      scopes: [
+        "channel:read:guest_star",
+        "channel:manage:guest_star",
+        "moderator:read:guest_star",
+        "moderator:manage:guest_star"
+      ],
+      context: "moderator_id",
+      options
+    });
+  }
+  createSession(params = {}, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "guest_star/session",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  endSession(params, options) {
+    return this.rest.first({
+      method: "DELETE",
+      path: "guest_star/session",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  invites(params, options) {
+    return this.rest.data({
+      path: "guest_star/invites",
+      query: params,
+      auth: "user",
+      scopes: [
+        "channel:read:guest_star",
+        "channel:manage:guest_star",
+        "moderator:read:guest_star",
+        "moderator:manage:guest_star"
+      ],
+      context: "moderator_id",
+      options
+    });
+  }
+  invite(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "guest_star/invites",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+  deleteInvite(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "guest_star/invites",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+  assignSlot(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "guest_star/slot",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+  updateSlot(params, options) {
+    return this.rest.send({
+      method: "PATCH",
+      path: "guest_star/slot",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+  deleteSlot(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "guest_star/slot",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+  updateSlotSettings(params, options) {
+    return this.rest.send({
+      method: "PATCH",
+      path: "guest_star/slot_settings",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:guest_star", "moderator:manage:guest_star"],
+      context: "moderator_id",
+      options
+    });
+  }
+};
+
+// src/api/hype-train.ts
+var HypeTrainApi = class extends ApiGroup {
+  status(params = {}, options) {
+    return this.rest.one({
+      path: "hypetrain/status",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:hype_train"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/moderation.ts
+var ModerationApi = class extends ApiGroup {
+  checkAutoMod(params, options) {
+    const { data, ...query } = params;
+    return this.rest.data({
+      method: "POST",
+      path: "moderation/enforcements/status",
+      query,
+      body: { data },
+      scopes: ["moderation:read"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  manageAutoModMessage(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "moderation/automod/message",
+      body: params,
+      scopes: ["moderator:manage:automod"],
+      context: { body: "user_id" },
+      options
+    });
+  }
+  autoModSettings(params, options) {
+    return this.rest.one({
+      path: "moderation/automod/settings",
+      query: params,
+      scopes: ["moderator:read:automod_settings", "moderator:manage:automod_settings"],
+      context: "moderator_id",
+      options
+    });
+  }
+  updateAutoModSettings(params, options) {
+    const { broadcaster_id, moderator_id, ...body } = params;
+    return this.rest.one({
+      method: "PUT",
+      path: "moderation/automod/settings",
+      query: { broadcaster_id, moderator_id },
+      body,
+      scopes: ["moderator:manage:automod_settings"],
+      context: "moderator_id",
+      options
+    });
+  }
+  bans(params = {}, options) {
+    return this.rest.paginate({
+      path: "moderation/banned",
+      query: params,
+      scopes: ["moderation:read", "moderator:manage:banned_users"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  ban(params, options) {
+    const { broadcaster_id, moderator_id, ...data } = params;
+    return this.rest.one({
+      method: "POST",
+      path: "moderation/bans",
+      query: { broadcaster_id, moderator_id },
+      body: { data },
+      scopes: ["moderator:manage:banned_users"],
+      context: "moderator_id",
+      options
+    });
+  }
+  unban(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "moderation/bans",
+      query: params,
+      scopes: ["moderator:manage:banned_users"],
+      context: "moderator_id",
+      options
+    });
+  }
+  unbanRequests(params, options) {
+    return this.rest.paginate({
+      path: "moderation/unban_requests",
+      query: params,
+      auth: "user",
+      scopes: ["moderator:read:unban_requests", "moderator:manage:unban_requests"],
+      context: "moderator_id",
+      options
+    });
+  }
+  resolveUnbanRequest(params, options) {
+    return this.rest.one({
+      method: "PATCH",
+      path: "moderation/unban_requests",
+      query: params,
+      auth: "user",
+      scopes: ["moderator:manage:unban_requests"],
+      context: "moderator_id",
+      options
+    });
+  }
+  blockedTerms(params, options) {
+    return this.rest.paginate({
+      path: "moderation/blocked_terms",
+      query: params,
+      scopes: ["moderator:read:blocked_terms", "moderator:manage:blocked_terms"],
+      context: "moderator_id",
+      options
+    });
+  }
+  addBlockedTerm(params, options) {
+    const { text, ...query } = params;
+    return this.rest.one({
+      method: "POST",
+      path: "moderation/blocked_terms",
+      query,
+      body: { text },
+      scopes: ["moderator:manage:blocked_terms"],
+      context: "moderator_id",
+      options
+    });
+  }
+  removeBlockedTerm(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "moderation/blocked_terms",
+      query: params,
+      scopes: ["moderator:manage:blocked_terms"],
+      context: "moderator_id",
+      options
+    });
+  }
+  deleteMessages(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "moderation/chat",
+      query: params,
+      scopes: ["moderator:manage:chat_messages"],
+      context: "moderator_id",
+      options
+    });
+  }
+  moderatedChannels(params = {}, options) {
+    return this.rest.paginate({
+      path: "moderation/channels",
+      query: params,
+      scopes: ["user:read:moderated_channels"],
+      context: "user_id",
+      options
+    });
+  }
+  moderators(params = {}, options) {
+    return this.rest.paginate({
+      path: "moderation/moderators",
+      query: params,
+      auth: "user",
+      scopes: ["moderation:read", "channel:manage:moderators"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  addModerator(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "moderation/moderators",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:moderators"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  removeModerator(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "moderation/moderators",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:moderators"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  vips(params = {}, options) {
+    return this.rest.paginate({
+      path: "channels/vips",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:vips", "channel:manage:vips"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  addVip(params, options) {
+    return this.rest.send({
+      method: "POST",
+      path: "channels/vips",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:vips"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  removeVip(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "channels/vips",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:vips"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  updateShieldMode(params, options) {
+    const { is_active, ...query } = params;
+    return this.rest.one({
+      method: "PUT",
+      path: "moderation/shield_mode",
+      query,
+      body: { is_active },
+      scopes: ["moderator:manage:shield_mode"],
+      context: "moderator_id",
+      options
+    });
+  }
+  shieldMode(params, options) {
+    return this.rest.one({
+      path: "moderation/shield_mode",
+      query: params,
+      scopes: ["moderator:read:shield_mode", "moderator:manage:shield_mode"],
+      context: "moderator_id",
+      options
+    });
+  }
+  warn(params, options) {
+    const { broadcaster_id, moderator_id, ...data } = params;
+    return this.rest.one({
+      method: "POST",
+      path: "moderation/warnings",
+      query: { broadcaster_id, moderator_id },
+      body: { data },
+      scopes: ["moderator:manage:warnings"],
+      context: "moderator_id",
+      options
+    });
+  }
+  addSuspiciousStatus(params, options) {
+    const { broadcaster_id, moderator_id, ...body } = params;
+    return this.rest.one({
+      method: "POST",
+      path: "moderation/suspicious_users",
+      query: { broadcaster_id, moderator_id },
+      body,
+      scopes: ["moderator:manage:suspicious_users"],
+      context: "moderator_id",
+      options
+    });
+  }
+  removeSuspiciousStatus(params, options) {
+    return this.rest.one({
+      method: "DELETE",
+      path: "moderation/suspicious_users",
+      query: params,
+      scopes: ["moderator:manage:suspicious_users"],
+      context: "moderator_id",
+      options
+    });
+  }
+};
+
+// src/api/polls.ts
+var PollsApi = class extends ApiGroup {
+  get(params = {}, options) {
+    return this.rest.paginate(
+      {
+        path: "polls",
+        query: params,
+        auth: "user",
+        scopes: ["channel:read:polls", "channel:manage:polls"],
+        context: "broadcaster_id",
+        options
+      },
+      { max: 20 }
+    );
+  }
+  create(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "polls",
+      body: {
+        ...params,
+        choices: params.choices.map((choice) => typeof choice === "string" ? { title: choice } : choice)
+      },
+      auth: "user",
+      scopes: ["channel:manage:polls"],
+      context: { body: "broadcaster_id" },
+      options
+    });
+  }
+  end(params, options) {
+    return this.rest.one({
+      method: "PATCH",
+      path: "polls",
+      body: params,
+      auth: "user",
+      scopes: ["channel:manage:polls"],
+      context: { body: "broadcaster_id" },
+      options
+    });
+  }
+};
+
+// src/api/predictions.ts
+var PredictionsApi = class extends ApiGroup {
+  get(params = {}, options) {
+    return this.rest.paginate(
+      {
+        path: "predictions",
+        query: params,
+        auth: "user",
+        scopes: ["channel:read:predictions", "channel:manage:predictions"],
+        context: "broadcaster_id",
+        options
+      },
+      { max: 25 }
+    );
+  }
+  create(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "predictions",
+      body: {
+        ...params,
+        outcomes: params.outcomes.map((outcome) => typeof outcome === "string" ? { title: outcome } : outcome)
+      },
+      auth: "user",
+      scopes: ["channel:manage:predictions"],
+      context: { body: "broadcaster_id" },
+      options
+    });
+  }
+  end(params, options) {
+    return this.rest.one({
+      method: "PATCH",
+      path: "predictions",
+      body: params,
+      auth: "user",
+      scopes: ["channel:manage:predictions"],
+      context: { body: "broadcaster_id" },
+      options
+    });
+  }
+};
+
+// src/api/raids.ts
+var RaidsApi = class extends ApiGroup {
+  start(params, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "raids",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:raids"],
+      context: "from_broadcaster_id",
+      options
+    });
+  }
+  cancel(params = {}, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "raids",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:raids"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/schedule.ts
+var ScheduleApi = class extends ApiGroup {
+  get(params, options) {
+    return this.rest.paginate(
+      { path: "schedule", query: params, options },
+      { max: 25, extract: (body) => ({ data: body.data.segments, cursor: body.pagination?.cursor }) }
+    );
+  }
+  icalendar(params, options) {
+    return this.rest.request({ path: "schedule/icalendar", query: params, response: "text", options });
+  }
+  updateSettings(params = {}, options) {
+    return this.rest.send({
+      method: "PATCH",
+      path: "schedule/settings",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:schedule"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  async createSegment(params, options) {
+    const { broadcaster_id, ...body } = params;
+    const response = await this.rest.request({
+      method: "POST",
+      path: "schedule/segment",
+      query: { broadcaster_id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:schedule"],
+      context: "broadcaster_id",
+      options
+    });
+    return response.data;
+  }
+  async updateSegment(params, options) {
+    const { broadcaster_id, id, ...body } = params;
+    const response = await this.rest.request({
+      method: "PATCH",
+      path: "schedule/segment",
+      query: { broadcaster_id, id },
+      body,
+      auth: "user",
+      scopes: ["channel:manage:schedule"],
+      context: "broadcaster_id",
+      options
+    });
+    return response.data;
+  }
+  deleteSegment(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "schedule/segment",
+      query: params,
+      auth: "user",
+      scopes: ["channel:manage:schedule"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+};
+
+// src/api/search.ts
+var SearchApi = class extends ApiGroup {
+  categories(params, options) {
+    return this.rest.paginate({ path: "search/categories", query: params, options });
+  }
+  channels(params, options) {
+    return this.rest.paginate({ path: "search/channels", query: params, options });
+  }
+};
+
+// src/api/streams.ts
+var StreamsApi = class extends ApiGroup {
+  get(params = {}, options) {
+    return this.rest.paginate({ path: "streams", query: params, options });
+  }
+  followed(params = {}, options) {
+    return this.rest.paginate({
+      path: "streams/followed",
+      query: params,
+      auth: "user",
+      scopes: ["user:read:follows"],
+      context: "user_id",
+      options
+    });
+  }
+  async key(params = {}, options) {
+    const { stream_key } = await this.rest.one({
+      path: "streams/key",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:stream_key"],
+      context: "broadcaster_id",
+      options
+    });
+    return stream_key;
+  }
+  createMarker(params = {}, options) {
+    return this.rest.one({
+      method: "POST",
+      path: "streams/markers",
+      body: params,
+      auth: "user",
+      scopes: ["channel:manage:broadcast"],
+      context: { body: "user_id" },
+      options
+    });
+  }
+  markers(params, options) {
+    return this.rest.paginate({
+      path: "streams/markers",
+      query: params,
+      auth: "user",
+      scopes: ["user:read:broadcast", "channel:manage:broadcast"],
+      options
+    });
+  }
+};
+
+// src/api/subscriptions.ts
+var SubscriptionsApi = class extends ApiGroup {
+  get(params = {}, options) {
+    return this.rest.paginate({
+      path: "subscriptions",
+      query: params,
+      auth: "user",
+      scopes: ["channel:read:subscriptions"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  async check(params, options) {
+    try {
+      return await this.rest.first({
+        path: "subscriptions/user",
+        query: params,
+        auth: "user",
+        scopes: ["user:read:subscriptions"],
+        context: "user_id",
+        options
+      });
+    } catch (error) {
+      if (error instanceof TwitchApiError && error.status === 404) return null;
+      throw error;
+    }
+  }
+};
+
+// src/api/tags.ts
+var TagsApi = class extends ApiGroup {
+  all(params = {}, options) {
+    return this.rest.paginate({ path: "tags/streams", query: params, options });
+  }
+  ofChannel(params, options) {
+    return this.rest.data({ path: "streams/tags", query: params, options });
+  }
+};
+
+// src/api/teams.ts
+var TeamsApi = class extends ApiGroup {
+  ofChannel(params, options) {
+    return this.rest.data({ path: "teams/channel", query: params, options });
+  }
+  async get(params, options) {
+    try {
+      return await this.rest.first({ path: "teams", query: params, options });
+    } catch (error) {
+      if (error instanceof TwitchApiError && error.status === 404) return null;
+      throw error;
+    }
+  }
+};
+
+// src/http/batcher.ts
+var Batcher = class {
+  #load;
+  #max;
+  #queue = /* @__PURE__ */ new Map();
+  #scheduled = false;
+  constructor(load, max = 100) {
+    this.#load = load;
+    this.#max = max;
+  }
+  get(key) {
+    return new Promise((resolve, reject) => {
+      const waiters = this.#queue.get(key);
+      if (waiters) waiters.push({ resolve, reject });
+      else this.#queue.set(key, [{ resolve, reject }]);
+      if (!this.#scheduled) {
+        this.#scheduled = true;
+        queueMicrotask(() => this.#flush());
+      }
+    });
+  }
+  #flush() {
+    const queue = this.#queue;
+    this.#queue = /* @__PURE__ */ new Map();
+    this.#scheduled = false;
+    for (const keys of chunk([...queue.keys()], this.#max)) {
+      this.#load(keys).then(
+        (found) => {
+          for (const key of keys) for (const waiter of queue.get(key)) waiter.resolve(found.get(key) ?? null);
+        },
+        (error) => {
+          for (const key of keys) for (const waiter of queue.get(key)) waiter.reject(error);
+        }
+      );
+    }
+  }
+};
+
+// src/api/users.ts
+var UsersApi = class extends ApiGroup {
+  #byId;
+  #byLogin;
+  constructor(rest) {
+    super(rest);
+    this.#byId = new Batcher(async (ids) => new Map((await this.get({ id: ids })).map((user) => [user.id, user])));
+    this.#byLogin = new Batcher(
+      async (logins) => new Map((await this.get({ login: logins })).map((user) => [user.login, user]))
+    );
+  }
+  get(params, options) {
+    return this.rest.chunked({ path: "users", query: params, options }, ["id", "login"]);
+  }
+  async getById(id, options) {
+    if (!options) return this.#byId.get(id);
+    return (await this.get({ id }, options))[0] ?? null;
+  }
+  async getByLogin(login, options) {
+    const key = login.toLowerCase();
+    if (!options) return this.#byLogin.get(key);
+    return (await this.get({ login: key }, options))[0] ?? null;
+  }
+  me(options) {
+    return this.rest.one({ path: "users", auth: "user", options });
+  }
+  update(params, options) {
+    return this.rest.one({
+      method: "PUT",
+      path: "users",
+      query: params,
+      auth: "user",
+      scopes: ["user:edit"],
+      options
+    });
+  }
+  authorization(params, options) {
+    return this.rest.chunked(
+      { path: "authorization/users", query: params, auth: "app", options },
+      ["user_id"],
+      10
+    );
+  }
+  blocks(params = {}, options) {
+    return this.rest.paginate({
+      path: "users/blocks",
+      query: params,
+      auth: "user",
+      scopes: ["user:read:blocked_users"],
+      context: "broadcaster_id",
+      options
+    });
+  }
+  block(params, options) {
+    return this.rest.send({
+      method: "PUT",
+      path: "users/blocks",
+      query: params,
+      auth: "user",
+      scopes: ["user:manage:blocked_users"],
+      options
+    });
+  }
+  unblock(params, options) {
+    return this.rest.send({
+      method: "DELETE",
+      path: "users/blocks",
+      query: params,
+      auth: "user",
+      scopes: ["user:manage:blocked_users"],
+      options
+    });
+  }
+  extensions(options) {
+    return this.rest.data({
+      path: "users/extensions/list",
+      auth: "user",
+      scopes: ["user:read:broadcast", "user:edit:broadcast"],
+      options
+    });
+  }
+  async activeExtensions(params = {}, options) {
+    const body = await this.rest.request({
+      path: "users/extensions",
+      query: params,
+      options
+    });
+    return body.data;
+  }
+  async updateExtensions(params, options) {
+    const body = await this.rest.request({
+      method: "PUT",
+      path: "users/extensions",
+      body: { data: params.data },
+      auth: "user",
+      scopes: ["user:edit:broadcast"],
+      options
+    });
+    return body.data;
+  }
+};
+
+// src/api/videos.ts
+var VideosApi = class extends ApiGroup {
+  get(params, options) {
+    return this.rest.paginate({ path: "videos", query: params, options });
+  }
+  async delete(params, options) {
+    const deleted = [];
+    for (const id of chunk(toArray(params.id), 5)) {
+      const ids = await this.rest.data({
+        method: "DELETE",
+        path: "videos",
+        query: { id },
+        auth: "user",
+        scopes: ["channel:manage:videos"],
+        options
+      });
+      deleted.push(...ids);
+    }
+    return deleted;
+  }
+};
+
+// src/api/whispers.ts
+var WhispersApi = class extends ApiGroup {
+  send(params, options) {
+    const { message, ...query } = params;
+    return this.rest.send({
+      method: "POST",
+      path: "whispers",
+      query,
+      body: { message },
+      auth: "user",
+      scopes: ["user:manage:whispers"],
+      context: "from_user_id",
+      options
+    });
+  }
+};
+
+// src/auth/tokens.ts
+var MemoryTokenStore = class {
+  #tokens = /* @__PURE__ */ new Map();
+  get(userId) {
+    return this.#tokens.get(userId);
+  }
+  set(userId, token) {
+    this.#tokens.set(userId, token);
+  }
+  delete(userId) {
+    this.#tokens.delete(userId);
+  }
+  list() {
+    return [...this.#tokens.keys()];
+  }
+};
+
+// src/auth/manager.ts
+var EXPIRY_MARGIN = 6e4;
+var HOUR = 36e5;
+var Auth = class {
+  clientId;
+  #secret;
+  #store;
+  #hasStore;
+  #fetch;
+  #authUrl;
+  #events;
+  #validate;
+  #timeout;
+  #retries;
+  #users = /* @__PURE__ */ new Map();
+  #refreshing = /* @__PURE__ */ new Map();
+  #removals = /* @__PURE__ */ new Map();
+  #app;
+  #appPending;
+  #restored;
+  #timer;
+  constructor(config) {
+    this.clientId = config.clientId;
+    this.#secret = config.clientSecret;
+    this.#hasStore = config.store !== void 0;
+    this.#store = config.store ?? new MemoryTokenStore();
+    this.#fetch = config.fetch;
+    this.#authUrl = config.authUrl.replace(/\/+$/, "");
+    this.#events = config.events;
+    this.#validate = config.validate;
+    this.#timeout = config.timeout;
+    this.#retries = config.retries;
+  }
+  get hasSecret() {
+    return this.#secret !== void 0;
+  }
+  get users() {
+    return [...this.#users.values()];
+  }
+  getUser(userId) {
+    return this.#users.get(userId);
+  }
+  hasUser(userId) {
+    return this.#users.has(userId);
+  }
+  async addUser(input) {
+    let accessToken = input.accessToken;
+    let refreshToken = input.refreshToken;
+    let expiresAt = input.expiresAt instanceof Date ? input.expiresAt.getTime() : input.expiresAt ?? (input.expiresIn ? Date.now() + input.expiresIn * 1e3 : void 0);
+    let userId = input.userId;
+    let login = input.login;
+    let scopes = input.scopes ? [...input.scopes] : void 0;
+    if (!userId || !scopes) {
+      let info;
+      try {
+        info = await this.validate(accessToken);
+      } catch (error) {
+        if (!(error instanceof TwitchApiError) || error.status !== 401 || !refreshToken) throw error;
+        const fresh = await this.#requestRefresh(refreshToken);
+        accessToken = fresh.access_token;
+        refreshToken = fresh.refresh_token ?? refreshToken;
+        expiresAt = fresh.expires_in ? Date.now() + fresh.expires_in * 1e3 : void 0;
+        info = await this.validate(accessToken);
+      }
+      if (!info.userId) {
+        throw new TwitchAuthError("This is an app access token, not a user access token.");
+      }
+      if (info.clientId !== this.clientId) {
+        throw new TwitchAuthError(
+          `This token was issued to another application (client ID ${info.clientId}), so it cannot be used with client ID ${this.clientId}.`,
+          { userId: info.userId }
+        );
+      }
+      userId = info.userId;
+      login = info.login ?? login;
+      scopes = info.scopes;
+      expiresAt ??= info.expiresAt;
+    }
+    const token = { userId, accessToken, scopes };
+    if (login) token.login = login;
+    if (refreshToken) token.refreshToken = refreshToken;
+    if (expiresAt !== void 0) token.expiresAt = expiresAt;
+    await this.#save(token);
+    return token;
+  }
+  async removeUser(userId, options = {}) {
+    const token = this.#users.get(userId);
+    this.#removals.set(userId, (this.#removals.get(userId) ?? 0) + 1);
+    this.#users.delete(userId);
+    await this.#store.delete(userId);
+    if (options.revoke && token) await this.revoke(token.accessToken).catch(() => {
+    });
+    if (this.#users.size === 0) this.#stopTimer();
+  }
+  restore() {
+    return this.#restored ??= (async () => {
+      const ids = await this.#store.list?.() ?? [];
+      const loaded = [];
+      for (const id of ids) {
+        if (this.#users.has(id)) continue;
+        const token = await this.#store.get(id);
+        if (token) {
+          this.#users.set(id, token);
+          loaded.push(token);
+        }
+      }
+      if (this.#users.size > 0) this.#startTimer();
+      return loaded;
+    })().catch((error) => {
+      this.#restored = void 0;
+      throw error;
+    });
+  }
+  authorizeUrl(options) {
+    const params = new URLSearchParams({
+      response_type: options.responseType ?? "code",
+      client_id: this.clientId,
+      redirect_uri: options.redirectUri,
+      scope: (options.scopes ?? []).join(" ")
+    });
+    if (options.state) params.set("state", options.state);
+    if (options.forceVerify) params.set("force_verify", "true");
+    return `${this.#authUrl}/authorize?${params}`;
+  }
+  async exchangeCode(code, redirectUri) {
+    const response = await this.#form("/token", {
+      client_id: this.clientId,
+      client_secret: this.#requireSecret("exchange an authorization code"),
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri
+    });
+    return this.#fromResponse(response);
+  }
+  async deviceFlow(options) {
+    const scopes = options.scopes.join(" ");
+    const start = await this.#form("/device", { client_id: this.clientId, scopes });
+    const expiresAt = Date.now() + start.expires_in * 1e3;
+    let interval = start.interval;
+    const wait = async (signal) => {
+      while (Date.now() < expiresAt) {
+        await sleep(interval * 1e3, signal);
+        try {
+          const response = await this.#form("/token", {
+            client_id: this.clientId,
+            ...this.#secret ? { client_secret: this.#secret } : {},
+            scopes,
+            device_code: start.device_code,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          });
+          return await this.#fromResponse(response);
+        } catch (error) {
+          if (error instanceof TwitchNetworkError || error instanceof TwitchTimeoutError) continue;
+          if (!(error instanceof TwitchApiError) || error.status !== 400) throw error;
+          if (/slow_down/i.test(error.message)) interval += 5;
+          else if (!/authorization_pending/i.test(error.message)) throw error;
+        }
+      }
+      throw new TwitchAuthError("The device code expired before the user approved the request.");
+    };
+    return {
+      userCode: start.user_code,
+      verificationUri: start.verification_uri,
+      deviceCode: start.device_code,
+      expiresAt,
+      get interval() {
+        return interval;
+      },
+      wait
+    };
+  }
+  refresh(userId) {
+    const pending = this.#refreshing.get(userId);
+    if (pending) return pending;
+    const run = (async () => {
+      const removals = this.#removals.get(userId) ?? 0;
+      const memory = this.#users.get(userId);
+      const stored = this.#hasStore ? await this.#store.get(userId) : void 0;
+      if (memory && stored && stored.accessToken !== memory.accessToken) {
+        this.#users.set(userId, stored);
+        return stored;
+      }
+      const current = memory ?? stored ?? await this.#store.get(userId);
+      if (!current) throw new TwitchAuthError(`No token is registered for user ${userId}.`, { userId });
+      if (!current.refreshToken) {
+        throw new TwitchAuthError(
+          `The access token of user ${userId} expired and there is no refresh token to renew it.`,
+          { userId }
+        );
+      }
+      let response;
+      try {
+        response = await this.#requestRefresh(current.refreshToken);
+      } catch (error) {
+        if (error instanceof TwitchApiError && error.status < 500 && /invalid refresh token/i.test(error.message)) {
+          const latest = this.#hasStore ? await this.#store.get(userId) : void 0;
+          if (latest && latest.refreshToken !== current.refreshToken) {
+            this.#users.set(userId, latest);
+            return latest;
+          }
+          const dead = new TwitchAuthError(
+            `Twitch rejected the refresh token of user ${userId}: ${error.message}. The user has to authorize the app again.`,
+            { cause: error, userId }
+          );
+          await this.#drop(userId, dead);
+          throw dead;
+        }
+        throw error;
+      }
+      const token = {
+        ...current,
+        accessToken: response.access_token,
+        refreshToken: response.refresh_token ?? current.refreshToken,
+        scopes: response.scope ?? current.scopes
+      };
+      if (response.expires_in) token.expiresAt = Date.now() + response.expires_in * 1e3;
+      else delete token.expiresAt;
+      if ((this.#removals.get(userId) ?? 0) !== removals) {
+        throw new TwitchAuthError(`User ${userId} was removed while their token was being renewed.`, { userId });
+      }
+      await this.#save(token);
+      this.#events.emit("tokenRefresh", token);
+      return token;
+    })().finally(() => this.#refreshing.delete(userId));
+    this.#refreshing.set(userId, run);
+    return run;
+  }
+  async validate(token) {
+    const url = `${this.#authUrl}/validate`;
+    const response = await this.#send("GET", url, { headers: { Authorization: `OAuth ${token}` } }, true);
+    const body = await response.json().catch(() => void 0);
+    if (!response.ok || !body) {
+      throw new TwitchApiError(body?.message ?? `Token validation failed with status ${response.status}`, {
+        status: response.status,
+        method: "GET",
+        url,
+        body,
+        headers: response.headers
+      });
+    }
+    const info = {
+      clientId: body.client_id,
+      userId: body.user_id || null,
+      login: body.login || null,
+      scopes: body.scopes ?? [],
+      expiresIn: body.expires_in ?? 0
+    };
+    if (body.expires_in) info.expiresAt = Date.now() + body.expires_in * 1e3;
+    return info;
+  }
+  async revoke(token) {
+    await this.#form("/revoke", { client_id: this.clientId, token });
+  }
+  appToken() {
+    if (this.#app && this.#app.expiresAt - EXPIRY_MARGIN > Date.now()) return Promise.resolve(this.#app.token);
+    return this.#appPending ??= (async () => {
+      const response = await this.#form(
+        "/token",
+        {
+          client_id: this.clientId,
+          client_secret: this.#requireSecret("get an app access token"),
+          grant_type: "client_credentials"
+        },
+        true
+      );
+      this.#app = {
+        token: response.access_token,
+        expiresAt: Date.now() + (response.expires_in ?? 3600) * 1e3
+      };
+      return response.access_token;
+    })().finally(() => {
+      this.#appPending = void 0;
+    });
+  }
+  async validateAll() {
+    await Promise.all(
+      [...this.#users.values()].map(async (user) => {
+        try {
+          const info = await this.validate(user.accessToken);
+          const current = this.#users.get(user.userId);
+          if (!current || current.accessToken !== user.accessToken) return;
+          current.scopes = info.scopes;
+          if (info.expiresAt !== void 0) current.expiresAt = info.expiresAt;
+        } catch (error) {
+          if (!(error instanceof TwitchApiError) || error.status !== 401) return;
+          if (user.refreshToken) await this.refresh(user.userId).catch(() => {
+          });
+          else await this.#drop(user.userId, new TwitchAuthError(`The token of user ${user.userId} is no longer valid.`, { cause: error, userId: user.userId }));
+        }
+      })
+    );
+  }
+  close() {
+    this.#stopTimer();
+  }
+  async resolve(need) {
+    if (need.token) return { token: need.token, kind: "raw", bucket: `raw:${fingerprint(need.token)}` };
+    if (need.as === "app") {
+      if (need.auth === "user") {
+        throw new TwitchAuthError(`${need.what} only accepts a user access token: the app token cannot be used for it.`);
+      }
+      return { token: await this.appToken(), kind: "app", bucket: "app" };
+    }
+    if (this.#hasStore) await this.restore();
+    if (need.as && need.auth !== "app") return this.#userGrant(need.as, need);
+    if (need.auth !== "app") {
+      if (need.contextId && await this.#known(need.contextId)) return this.#userGrant(need.contextId, need);
+      if (need.auth === "user") {
+        const sole = this.#sole();
+        if (sole) return this.#userGrant(sole, need);
+        throw new TwitchAuthError(
+          this.#users.size === 0 ? `${need.what} needs a user access token and no user is registered. Add one with twitch.auth.addUser().` : need.contextId ? `${need.what} needs the token of user ${need.contextId}, which is not registered. Add it with twitch.auth.addUser() or choose a user with { as: userId }.` : `${need.what} needs a user access token and several users are registered. Choose one with { as: userId } or twitch.as(userId).`
+        );
+      }
+      if (need.contextMissing || need.preferUser) {
+        const sole = this.#sole();
+        if (sole) return this.#userGrant(sole, need);
+      }
+    }
+    if (this.#secret) return { token: await this.appToken(), kind: "app", bucket: "app" };
+    if (need.auth === "any") {
+      const sole = this.#sole();
+      if (sole) return this.#userGrant(sole, need);
+    }
+    if (need.auth === "any" && this.#users.size > 1) {
+      throw new TwitchAuthError(
+        `${need.what} can use a user token, but several users are registered. Choose one with { as: userId } or twitch.as(userId).`
+      );
+    }
+    throw new TwitchAuthError(
+      `${need.what} needs an app access token, which requires a clientSecret${need.auth === "any" ? " (or a registered user token)" : ""}.`
+    );
+  }
+  async renew(grant) {
+    if (grant.kind === "raw") return null;
+    if (grant.kind === "app" && this.#app && this.#app.token !== grant.token) {
+      return { ...grant, token: this.#app.token };
+    }
+    const user = grant.userId ? this.#users.get(grant.userId) : void 0;
+    if (user && user.accessToken !== grant.token) return { ...grant, token: user.accessToken };
+    try {
+      await this.validate(grant.token);
+      return null;
+    } catch (error) {
+      if (!(error instanceof TwitchApiError) || error.status !== 401) return null;
+    }
+    if (grant.kind === "app") {
+      if (this.#app?.token === grant.token) this.#app = void 0;
+      return { ...grant, token: await this.appToken() };
+    }
+    const userId = grant.userId;
+    if (user && !user.refreshToken) {
+      const dead = new TwitchAuthError(
+        `The access token of user ${userId} is no longer valid and there is no refresh token to renew it. The user has to authorize the app again.`,
+        { userId }
+      );
+      await this.#drop(userId, dead);
+      throw dead;
+    }
+    return { ...grant, token: (await this.refresh(userId)).accessToken };
+  }
+  async #userGrant(userId, need) {
+    let token = this.#users.get(userId);
+    if (!token) {
+      if (!await this.#known(userId)) {
+        throw new TwitchAuthError(
+          `No token is registered for user ${userId}. Add it with twitch.auth.addUser().`,
+          { userId }
+        );
+      }
+      token = this.#users.get(userId);
+    }
+    if (token.expiresAt !== void 0 && token.expiresAt - EXPIRY_MARGIN <= Date.now() && token.refreshToken) {
+      token = await this.refresh(userId);
+    }
+    if (need.scopes?.length && !need.scopes.some((scope) => token.scopes.includes(scope))) {
+      throw new TwitchScopeError(userId, need.scopes, token.scopes, need.what);
+    }
+    return { token: token.accessToken, kind: "user", userId, bucket: `user:${userId}` };
+  }
+  async #known(userId) {
+    if (this.#users.has(userId)) return true;
+    if (!this.#hasStore) return false;
+    const token = await this.#store.get(userId);
+    if (!token) return false;
+    this.#users.set(userId, token);
+    this.#startTimer();
+    return true;
+  }
+  #sole() {
+    if (this.#users.size !== 1) return void 0;
+    return this.#users.keys().next().value;
+  }
+  async #save(token) {
+    this.#users.set(token.userId, token);
+    await this.#store.set(token.userId, token);
+    this.#startTimer();
+  }
+  async #drop(userId, error) {
+    this.#users.delete(userId);
+    await Promise.resolve(this.#store.delete(userId)).catch(() => {
+    });
+    if (this.#users.size === 0) this.#stopTimer();
+    this.#events.emit("tokenInvalid", userId, error);
+  }
+  async #fromResponse(response) {
+    const input = { accessToken: response.access_token };
+    if (response.refresh_token) input.refreshToken = response.refresh_token;
+    if (response.expires_in) input.expiresIn = response.expires_in;
+    return this.addUser(input);
+  }
+  #requestRefresh(refreshToken) {
+    return this.#form("/token", {
+      client_id: this.clientId,
+      ...this.#secret ? { client_secret: this.#secret } : {},
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    });
+  }
+  #requireSecret(action) {
+    if (!this.#secret) throw new TwitchAuthError(`A clientSecret is required to ${action}.`);
+    return this.#secret;
+  }
+  async #form(path, params, repeatable = false) {
+    const url = `${this.#authUrl}${path}`;
+    const response = await this.#send(
+      "POST",
+      url,
+      { headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(params).toString() },
+      repeatable
+    );
+    const text = await response.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : void 0;
+    } catch {
+      body = text;
+    }
+    if (!response.ok) {
+      const message = body?.message ?? `OAuth request failed with status ${response.status}`;
+      throw new TwitchApiError(message, {
+        status: response.status,
+        method: "POST",
+        url,
+        body,
+        headers: response.headers
+      });
+    }
+    return body;
+  }
+  async #send(method, url, init, repeatable) {
+    const what = `${method} ${new URL(url).pathname}`;
+    for (let attempt = 0; ; attempt++) {
+      const again = repeatable && attempt < this.#retries;
+      try {
+        const response = await this.#fetch(url, { ...init, method, signal: AbortSignal.timeout(this.#timeout) });
+        if (response.status < 500 || !again) return response;
+      } catch (error) {
+        if (!again) {
+          if (error instanceof Error && error.name === "TimeoutError") {
+            throw new TwitchTimeoutError(`${what} timed out after ${this.#timeout} ms.`, { cause: error });
+          }
+          throw new TwitchNetworkError(`${what} could not reach Twitch: ${error.message}`, { cause: error });
+        }
+      }
+      await sleep(backoff(attempt));
+    }
+  }
+  #startTimer() {
+    if (!this.#validate || this.#timer) return;
+    this.#timer = unref(setInterval(() => void this.validateAll(), HOUR));
+  }
+  #stopTimer() {
+    if (this.#timer) clearInterval(this.#timer);
+    this.#timer = void 0;
+  }
+};
+
+// src/http/rate-limit.ts
+var RateLimiter = class {
+  #buckets = /* @__PURE__ */ new Map();
+  #events;
+  constructor(events) {
+    this.#events = events;
+  }
+  get(bucket) {
+    return this.#buckets.get(bucket);
+  }
+  reserve(bucket) {
+    const state = this.#buckets.get(bucket);
+    if (!state) return 0;
+    const now = Date.now();
+    if (now >= state.resetAt) {
+      this.#buckets.delete(bucket);
+      return 0;
+    }
+    if (state.remaining > 0) {
+      state.remaining--;
+      return 0;
+    }
+    return state.resetAt - now;
+  }
+  async acquire(bucket, signal) {
+    for (; ; ) {
+      const waitMs = this.reserve(bucket);
+      if (waitMs <= 0) return;
+      this.#events.emit("rateLimit", { bucket, waitMs, resetAt: Date.now() + waitMs });
+      await sleep(waitMs + 25, signal);
+    }
+  }
+  update(bucket, headers) {
+    const limit = Number(headers.get("ratelimit-limit"));
+    const remainingHeader = headers.get("ratelimit-remaining");
+    const reset = Number(headers.get("ratelimit-reset"));
+    if (!limit || remainingHeader === null || !reset) return void 0;
+    const remaining = Number(remainingHeader);
+    const resetAt = reset * 1e3;
+    const state = this.#buckets.get(bucket);
+    if (state && state.resetAt === resetAt) {
+      state.limit = limit;
+      state.remaining = Math.min(state.remaining, remaining);
+    } else {
+      this.#buckets.set(bucket, { limit, remaining, resetAt });
+    }
+    return remaining;
+  }
+  exhaust(bucket, resetAt) {
+    const state = this.#buckets.get(bucket);
+    if (state) {
+      state.remaining = 0;
+      state.resetAt = Math.max(state.resetAt, resetAt);
+    } else {
+      this.#buckets.set(bucket, { limit: 0, remaining: 0, resetAt });
+    }
+  }
+};
+
+// src/http/pagination.ts
+var Page = class _Page {
+  data;
+  cursor;
+  total;
+  raw;
+  #fetch;
+  #size;
+  constructor(result, fetch, size) {
+    this.data = result.data;
+    this.cursor = result.cursor;
+    this.total = result.total;
+    this.raw = result.raw;
+    this.#fetch = fetch;
+    this.#size = size;
+  }
+  get hasNext() {
+    return this.cursor !== void 0;
+  }
+  async next() {
+    if (this.cursor === void 0) return null;
+    return new _Page(await this.#fetch(this.cursor, this.#size), this.#fetch, this.#size);
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+};
+var Paginator = class {
+  #fetch;
+  #size;
+  #maxSize;
+  #first;
+  constructor(fetch, size, maxSize) {
+    this.#fetch = fetch;
+    this.#size = size;
+    this.#maxSize = maxSize;
+  }
+  then(onfulfilled, onrejected) {
+    this.#first ??= this.#fetch(void 0, this.#size).then((result) => new Page(result, this.#fetch, this.#size));
+    return this.#first.then(onfulfilled, onrejected);
+  }
+  async *pages() {
+    const size = this.#size ?? this.#maxSize;
+    let page = new Page(await this.#fetch(void 0, size), this.#fetch, size);
+    const seen = /* @__PURE__ */ new Set();
+    while (page) {
+      yield page;
+      if (page.cursor === void 0 || seen.has(page.cursor)) return;
+      seen.add(page.cursor);
+      page = await page.next();
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.pages()) yield* page.data;
+  }
+  async all(options = {}) {
+    const limit = options.limit ?? Infinity;
+    const items = [];
+    if (limit <= 0) return items;
+    const size = this.#size ?? Math.min(this.#maxSize, limit);
+    let cursor;
+    const seen = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      const result = await this.#fetch(cursor, size);
+      for (const item of result.data) {
+        items.push(item);
+        if (items.length >= limit) return items;
+      }
+      if (result.cursor === void 0 || seen.has(result.cursor)) return items;
+      seen.add(result.cursor);
+      cursor = result.cursor;
+    }
+  }
+  take(count) {
+    return this.all({ limit: count });
+  }
+  async first() {
+    const size = this.#size ?? 1;
+    return (await this.#fetch(void 0, size)).data[0];
+  }
+  async total() {
+    return (await this.#fetch(void 0, 1)).total;
+  }
+};
+
+// src/http/rest.ts
+function buildQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) if (item !== void 0 && item !== null) params.append(key, format(item));
+    } else {
+      params.append(key, format(value));
+    }
+  }
+  const text = params.toString();
+  return text ? `?${text}` : "";
+}
+function format(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+var IDEMPOTENT = /* @__PURE__ */ new Set(["GET", "PUT", "DELETE"]);
+var Rest = class _Rest {
+  #config;
+  #as;
+  constructor(config, as) {
+    this.#config = config;
+    this.#as = as;
+  }
+  onClose(close) {
+    this.#config.closers.add(close);
+  }
+  withUser(userId) {
+    return new _Rest(this.#config, userId);
+  }
+  async request(endpoint) {
+    const config = this.#config;
+    const method = endpoint.method ?? "GET";
+    const options = endpoint.options ?? {};
+    const what = `${method} /${endpoint.path}`;
+    const query = { ...endpoint.query };
+    const body = endpoint.body ? { ...endpoint.body } : void 0;
+    const context = endpoint.context;
+    const contextKey = typeof context === "string" ? context : context?.body;
+    const contextBag = typeof context === "string" ? query : body;
+    const contextValue = contextKey ? contextBag?.[contextKey] : void 0;
+    let grant = await config.auth.resolve({
+      auth: endpoint.auth ?? "any",
+      scopes: endpoint.scopes,
+      as: options.as ?? this.#as,
+      token: options.token,
+      contextId: typeof contextValue === "string" ? contextValue : void 0,
+      contextMissing: contextKey !== void 0 && (contextValue === void 0 || contextValue === null),
+      preferUser: endpoint.prefer === "user",
+      what
+    });
+    if (contextKey && contextBag && (contextValue === void 0 || contextValue === null)) {
+      if (grant.userId) contextBag[contextKey] = grant.userId;
+      else if (grant.kind === "raw") {
+        throw new TwitchAuthError(`${what} needs "${contextKey}": a token passed by hand does not say who it belongs to.`);
+      } else if (config.auth.users.length > 1) {
+        throw new TwitchAuthError(
+          `${what} does not say who is acting and several users are registered. Set "${contextKey}", or choose a user with { as: userId } or twitch.as(userId).`
+        );
+      } else {
+        throw new TwitchAuthError(
+          `${what} needs "${contextKey}": the call is made with the app token, which belongs to no user. Set "${contextKey}", or register the acting user with twitch.auth.addUser().`
+        );
+      }
+    }
+    const url = `${config.baseUrl}/${endpoint.path}${buildQuery(query)}`;
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    const retries = options.retries ?? config.retries;
+    const timeout = options.timeout ?? config.timeout;
+    let renewed = false;
+    for (let attempt = 0; ; attempt++) {
+      options.signal?.throwIfAborted();
+      if (config.rateLimit === "wait") await config.limiter.acquire(grant.bucket, options.signal);
+      else {
+        const waitMs = config.limiter.reserve(grant.bucket);
+        if (waitMs > 0) {
+          throw new TwitchRateLimitError(
+            `Rate limit reached for ${what}.`,
+            { status: 429, method, url },
+            Date.now() + waitMs
+          );
+        }
+      }
+      const headers = {
+        Authorization: `Bearer ${grant.token}`,
+        "Client-Id": config.auth.clientId
+      };
+      if (payload !== void 0) headers["Content-Type"] = "application/json";
+      if (config.userAgent) headers["User-Agent"] = config.userAgent;
+      const as = grant.kind === "user" ? grant.userId : grant.kind;
+      const started = Date.now();
+      config.events.emit("request", { method, url, attempt: attempt + 1, as });
+      let response;
+      let text;
+      try {
+        const signals = [AbortSignal.timeout(timeout)];
+        if (options.signal) signals.push(options.signal);
+        const init = { method, headers, signal: AbortSignal.any(signals) };
+        if (payload !== void 0) init.body = payload;
+        response = await config.fetch(url, init);
+        text = response.status === 204 ? "" : await response.text();
+      } catch (error) {
+        if (options.signal?.aborted) throw options.signal.reason;
+        const timedOut = error instanceof Error && error.name === "TimeoutError";
+        if (attempt < retries && IDEMPOTENT.has(method)) {
+          await sleep(backoff(attempt), options.signal);
+          continue;
+        }
+        if (timedOut) throw new TwitchTimeoutError(`${what} timed out after ${timeout} ms.`, { cause: error });
+        throw new TwitchNetworkError(`${what} could not reach Twitch: ${error.message}`, { cause: error });
+      }
+      const remaining = config.limiter.update(grant.bucket, response.headers);
+      const event = {
+        method,
+        url,
+        attempt: attempt + 1,
+        as,
+        status: response.status,
+        duration: Date.now() - started
+      };
+      if (remaining !== void 0) event.remaining = remaining;
+      config.events.emit("response", event);
+      if (response.ok) {
+        if (endpoint.response === "text") return text;
+        if (!text) return void 0;
+        try {
+          return JSON.parse(text);
+        } catch (error) {
+          throw new TwitchError(`${what} answered with a body that is not JSON.`, { cause: error });
+        }
+      }
+      const failure = readError(response, text, method, url);
+      if (response.status === 401 && !renewed) {
+        renewed = true;
+        const fresh = await config.auth.renew(grant);
+        if (fresh) {
+          grant = fresh;
+          attempt--;
+          continue;
+        }
+      }
+      if (response.status === 429) {
+        const reset = Number(response.headers.get("ratelimit-reset"));
+        const bucketEmpty = response.headers.get("ratelimit-remaining") === "0" && reset > 0;
+        const resetAt = bucketEmpty ? reset * 1e3 : Date.now() + backoff(attempt, 1e3, 3e4);
+        if (bucketEmpty) config.limiter.exhaust(grant.bucket, resetAt);
+        if (config.rateLimit === "wait" && attempt < retries) {
+          if (!bucketEmpty) {
+            config.events.emit("rateLimit", { bucket: grant.bucket, waitMs: resetAt - Date.now(), resetAt });
+            await sleep(Math.max(0, resetAt - Date.now()), options.signal);
+          }
+          continue;
+        }
+        throw new TwitchRateLimitError(failure.message, failure.info, resetAt);
+      }
+      if (response.status >= 500 && attempt < retries && IDEMPOTENT.has(method)) {
+        await sleep(backoff(attempt), options.signal);
+        continue;
+      }
+      throw new TwitchApiError(failure.message, failure.info);
+    }
+  }
+  async data(endpoint) {
+    const body = await this.request(endpoint);
+    return body?.data ?? [];
+  }
+  async one(endpoint) {
+    const [item] = await this.data(endpoint);
+    if (item === void 0) {
+      throw new TwitchError(`${endpoint.method ?? "GET"} /${endpoint.path} returned no data.`);
+    }
+    return item;
+  }
+  async first(endpoint) {
+    const [item] = await this.data(endpoint);
+    return item ?? null;
+  }
+  async send(endpoint) {
+    await this.request(endpoint);
+  }
+  async chunked(endpoint, keys, size = 100) {
+    const query = { ...endpoint.query };
+    const pairs = [];
+    for (const key of keys) {
+      const value = query[key];
+      if (value === void 0 || value === null) continue;
+      for (const item of Array.isArray(value) ? value : [value]) pairs.push([key, item]);
+      delete query[key];
+    }
+    if (pairs.length <= size) return this.data(endpoint);
+    const results = await Promise.all(
+      chunk(pairs, size).map((group) => {
+        const part = { ...query };
+        for (const [key, value] of group) (part[key] ??= []).push(value);
+        return this.data({ ...endpoint, query: part });
+      })
+    );
+    return results.flat();
+  }
+  paginate(endpoint, config = {}) {
+    const query = endpoint.query ?? {};
+    const sizeParam = config.sizeParam === void 0 ? "first" : config.sizeParam;
+    const backward = query["before"] !== void 0 && query["before"] !== null;
+    const cursorParam = backward ? "before" : "after";
+    const size = sizeParam !== null && typeof query[sizeParam] === "number" ? query[sizeParam] : void 0;
+    const extract = config.extract ?? defaultExtract;
+    const fetchPage = async (cursor, pageSize) => {
+      const next = { ...query };
+      if (cursor !== void 0) next[cursorParam] = cursor;
+      if (pageSize !== void 0 && sizeParam !== null) next[sizeParam] = pageSize;
+      const raw = await this.request({ ...endpoint, query: next });
+      const { data, cursor: nextCursor, total } = extract(raw);
+      return { data: data ?? [], cursor: nextCursor || void 0, total, raw };
+    };
+    return new Paginator(fetchPage, size, config.max ?? 100);
+  }
+};
+function defaultExtract(body) {
+  const shape = body ?? {};
+  const cursor = typeof shape.pagination === "string" ? shape.pagination : shape.pagination?.cursor;
+  return { data: shape.data, cursor, total: shape.total ?? void 0 };
+}
+function readError(response, text, method, url) {
+  let body = text;
+  try {
+    body = text ? JSON.parse(text) : void 0;
+  } catch {
+  }
+  const shape = typeof body === "object" && body !== null ? body : {};
+  const message = shape.message || shape.error || typeof body === "string" && body || response.statusText || "Request failed";
+  const info = {
+    status: response.status,
+    method,
+    url,
+    body,
+    headers: response.headers
+  };
+  if (shape.error) info.error = shape.error;
+  return { message: `${message} (${response.status} on ${method} ${new URL(url).pathname})`, info };
+}
+
+// src/client.ts
+var Twitch = class _Twitch {
+  #shared;
+  #rest;
+  #groups = /* @__PURE__ */ new Map();
+  userId;
+  constructor(options, shared, userId) {
+    if (shared) {
+      this.#shared = shared;
+      this.#rest = new Rest(shared.config, userId);
+      this.userId = userId;
+      return;
+    }
+    if (!options || typeof options.clientId !== "string" || options.clientId === "") {
+      throw new TwitchError("A clientId is required: new Twitch({ clientId, clientSecret }).");
+    }
+    if (typeof (options.fetch ?? globalThis.fetch) !== "function") {
+      throw new TwitchError("No fetch implementation found. Pass one with the `fetch` option.");
+    }
+    const doFetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    const events = new Emitter();
+    const auth = new Auth({
+      clientId: options.clientId,
+      clientSecret: options.clientSecret,
+      store: options.tokens,
+      fetch: doFetch,
+      authUrl: options.authUrl ?? "https://id.twitch.tv/oauth2",
+      events,
+      validate: options.validateTokens ?? true,
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3
+    });
+    const limiter = new RateLimiter(events);
+    const config = {
+      auth,
+      limiter,
+      events,
+      fetch: doFetch,
+      baseUrl: (options.baseUrl ?? "https://api.twitch.tv/helix").replace(/\/+$/, ""),
+      timeout: options.timeout ?? 15e3,
+      retries: options.retries ?? 3,
+      rateLimit: options.rateLimit ?? "wait",
+      userAgent: options.userAgent,
+      closers: /* @__PURE__ */ new Set()
+    };
+    this.#shared = { auth, events, limiter, config };
+    this.#rest = new Rest(config);
+    this.userId = void 0;
+  }
+  get auth() {
+    return this.#shared.auth;
+  }
+  get ads() {
+    return this.#group(AdsApi);
+  }
+  get analytics() {
+    return this.#group(AnalyticsApi);
+  }
+  get bits() {
+    return this.#group(BitsApi);
+  }
+  get channels() {
+    return this.#group(ChannelsApi);
+  }
+  get channelPoints() {
+    return this.#group(ChannelPointsApi);
+  }
+  get charity() {
+    return this.#group(CharityApi);
+  }
+  get chat() {
+    return this.#group(ChatApi);
+  }
+  get clips() {
+    return this.#group(ClipsApi);
+  }
+  get conduits() {
+    return this.#group(ConduitsApi);
+  }
+  get contentLabels() {
+    return this.#group(ContentLabelsApi);
+  }
+  get entitlements() {
+    return this.#group(EntitlementsApi);
+  }
+  get extensions() {
+    return this.#group(ExtensionsApi);
+  }
+  get eventsub() {
+    return this.#group(EventSubApi);
+  }
+  get games() {
+    return this.#group(GamesApi);
+  }
+  get goals() {
+    return this.#group(GoalsApi);
+  }
+  get guestStar() {
+    return this.#group(GuestStarApi);
+  }
+  get hypeTrain() {
+    return this.#group(HypeTrainApi);
+  }
+  get moderation() {
+    return this.#group(ModerationApi);
+  }
+  get polls() {
+    return this.#group(PollsApi);
+  }
+  get predictions() {
+    return this.#group(PredictionsApi);
+  }
+  get raids() {
+    return this.#group(RaidsApi);
+  }
+  get schedule() {
+    return this.#group(ScheduleApi);
+  }
+  get search() {
+    return this.#group(SearchApi);
+  }
+  get streams() {
+    return this.#group(StreamsApi);
+  }
+  get subscriptions() {
+    return this.#group(SubscriptionsApi);
+  }
+  get tags() {
+    return this.#group(TagsApi);
+  }
+  get teams() {
+    return this.#group(TeamsApi);
+  }
+  get users() {
+    return this.#group(UsersApi);
+  }
+  get videos() {
+    return this.#group(VideosApi);
+  }
+  get whispers() {
+    return this.#group(WhispersApi);
+  }
+  as(userId) {
+    return new _Twitch({ clientId: this.#shared.auth.clientId }, this.#shared, userId);
+  }
+  request(endpoint) {
+    return this.#rest.request(endpoint);
+  }
+  paginate(endpoint, config) {
+    return this.#rest.paginate(endpoint, config);
+  }
+  on(event, listener) {
+    return this.#shared.events.on(event, listener);
+  }
+  once(event, listener) {
+    return this.#shared.events.once(event, listener);
+  }
+  off(event, listener) {
+    this.#shared.events.off(event, listener);
+  }
+  rateLimitOf(userId) {
+    const state = this.#shared.limiter.get(userId ? `user:${userId}` : "app");
+    return state && state.resetAt > Date.now() ? { ...state } : void 0;
+  }
+  close() {
+    this.#shared.auth.close();
+    for (const close of this.#shared.config.closers) close();
+    this.#shared.config.closers.clear();
+  }
+  #group(Group) {
+    let group = this.#groups.get(Group);
+    if (!group) this.#groups.set(Group, group = new Group(this.#rest));
+    return group;
+  }
+};
+
+// src/auth/scopes.ts
+var SCOPES = [
+  "analytics:read:extensions",
+  "analytics:read:games",
+  "bits:read",
+  "channel:bot",
+  "channel:edit:commercial",
+  "channel:manage:ads",
+  "channel:manage:broadcast",
+  "channel:manage:clips",
+  "channel:manage:extensions",
+  "channel:manage:guest_star",
+  "channel:manage:moderators",
+  "channel:manage:polls",
+  "channel:manage:predictions",
+  "channel:manage:raids",
+  "channel:manage:redemptions",
+  "channel:manage:schedule",
+  "channel:manage:videos",
+  "channel:manage:vips",
+  "channel:moderate",
+  "channel:read:ads",
+  "channel:read:charity",
+  "channel:read:editors",
+  "channel:read:goals",
+  "channel:read:guest_star",
+  "channel:read:hype_train",
+  "channel:read:polls",
+  "channel:read:predictions",
+  "channel:read:redemptions",
+  "channel:read:stream_key",
+  "channel:read:subscriptions",
+  "channel:read:vips",
+  "chat:edit",
+  "chat:read",
+  "clips:edit",
+  "editor:manage:clips",
+  "moderation:read",
+  "moderator:manage:announcements",
+  "moderator:manage:automod",
+  "moderator:manage:automod_settings",
+  "moderator:manage:banned_users",
+  "moderator:manage:blocked_terms",
+  "moderator:manage:chat_messages",
+  "moderator:manage:chat_settings",
+  "moderator:manage:guest_star",
+  "moderator:manage:shield_mode",
+  "moderator:manage:shoutouts",
+  "moderator:manage:suspicious_users",
+  "moderator:manage:unban_requests",
+  "moderator:manage:warnings",
+  "moderator:read:automod_settings",
+  "moderator:read:banned_users",
+  "moderator:read:blocked_terms",
+  "moderator:read:chat_messages",
+  "moderator:read:chat_settings",
+  "moderator:read:chatters",
+  "moderator:read:followers",
+  "moderator:read:guest_star",
+  "moderator:read:moderators",
+  "moderator:read:shield_mode",
+  "moderator:read:shoutouts",
+  "moderator:read:suspicious_users",
+  "moderator:read:unban_requests",
+  "moderator:read:vips",
+  "moderator:read:warnings",
+  "user:bot",
+  "user:edit",
+  "user:edit:broadcast",
+  "user:manage:blocked_users",
+  "user:manage:chat_color",
+  "user:manage:whispers",
+  "user:read:blocked_users",
+  "user:read:broadcast",
+  "user:read:chat",
+  "user:read:email",
+  "user:read:emotes",
+  "user:read:follows",
+  "user:read:moderated_channels",
+  "user:read:subscriptions",
+  "user:read:whispers",
+  "user:write:chat",
+  "whispers:read"
+];
+
+export { AdsApi, AnalyticsApi, Auth, BitsApi, ChannelPointsApi, ChannelsApi, CharityApi, ChatApi, ClipsApi, ConduitsApi, ContentLabelsApi, EVENTSUB_VERSIONS, EntitlementsApi, EventSubApi, EventSubListener, EventSubWebSocket, EventSubWebhook, ExtensionsApi, GamesApi, GoalsApi, GuestStarApi, HypeTrainApi, MemoryTokenStore, ModerationApi, Page, Paginator, PollsApi, PredictionsApi, RaidsApi, SCOPES, ScheduleApi, SearchApi, StreamsApi, SubscriptionsApi, TagsApi, TeamsApi, Twitch, TwitchApiError, TwitchAuthError, TwitchError, TwitchEventSubError, TwitchNetworkError, TwitchRateLimitError, TwitchScopeError, TwitchTimeoutError, UsersApi, VideosApi, WhispersApi, activityVersions, channelVersions, chatVersions, resolveEventSubType, verifyEventSubSignature };