@openclaw/discord 2026.9.2 → 2026.9.3

package/dist/allow-list-DBTtR2dz.js

@@ -1,363 +0,0 @@
-import { parseDateStringTimestampMs } from "openclaw/plugin-sdk/number-runtime";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { buildChannelKeyCandidates, resolveChannelEntryMatchWithFallback, resolveChannelMatchConfig } from "openclaw/plugin-sdk/channel-targets";
-import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
-//#region extensions/discord/src/monitor/format.ts
-function resolveDiscordSystemLocation(params) {
-	const { isDirectMessage, isGroupDm, guild, channelName } = params;
-	if (isDirectMessage) return "DM";
-	if (isGroupDm) return `Group DM #${channelName}`;
-	return guild?.name ? `${guild.name} #${channelName}` : `#${channelName}`;
-}
-function formatDiscordReactionEmoji(emoji) {
-	if (emoji.id && emoji.name) return `<:${emoji.name}:${emoji.id}>`;
-	if (emoji.id) return `emoji:${emoji.id}`;
-	return emoji.name ?? "emoji";
-}
-function formatDiscordUserTag(user) {
-	const discriminator = (user.discriminator ?? "").trim();
-	if (discriminator && discriminator !== "0") return `${user.username}#${discriminator}`;
-	return user.username ?? user.id;
-}
-function resolveTimestampMs(timestamp) {
-	return parseDateStringTimestampMs(timestamp);
-}
-//#endregion
-//#region extensions/discord/src/monitor/allow-list.ts
-const DISCORD_OWNER_ALLOWLIST_PREFIXES = [
-	"discord:",
-	"user:",
-	"pk:"
-];
-function normalizeDiscordAllowList(raw, prefixes) {
-	if (!raw || raw.length === 0) return null;
-	const ids = /* @__PURE__ */ new Set();
-	const names = /* @__PURE__ */ new Set();
-	const allowAll = raw.some((entry) => (normalizeOptionalString(entry) ?? "") === "*");
-	for (const entry of raw) {
-		const text = normalizeOptionalString(entry) ?? "";
-		if (!text || text === "*") continue;
-		const normalized = normalizeDiscordSlug(text);
-		const maybeId = text.replace(/^<@!?/, "").replace(/>$/, "");
-		if (/^\d+$/.test(maybeId)) {
-			ids.add(maybeId);
-			continue;
-		}
-		const prefix = prefixes.find((entryLocal) => text.startsWith(entryLocal));
-		if (prefix) {
-			const candidate = text.slice(prefix.length);
-			if (candidate) ids.add(candidate);
-			continue;
-		}
-		if (normalized) names.add(normalized);
-	}
-	return {
-		allowAll,
-		ids,
-		names
-	};
-}
-function normalizeDiscordSlug(value) {
-	return normalizeLowercaseStringOrEmpty(value).replace(/^#/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function normalizeDiscordDisplaySlug(value) {
-	return normalizeLowercaseStringOrEmpty(value).normalize("NFC").replace(/^#/, "").replace(/[\s_]+/g, "-").replace(/[^\p{L}\p{M}\p{N}-]+/gu, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
-}
-function resolveDiscordAllowListNameMatch(list, candidate) {
-	const nameSlug = candidate.name ? normalizeDiscordSlug(candidate.name) : "";
-	if (nameSlug && list.names.has(nameSlug)) return {
-		matchKey: nameSlug,
-		matchSource: "name"
-	};
-	const tagSlug = candidate.tag ? normalizeDiscordSlug(candidate.tag) : "";
-	if (tagSlug && list.names.has(tagSlug)) return {
-		matchKey: tagSlug,
-		matchSource: "tag"
-	};
-	return null;
-}
-function allowListMatches(list, candidate, params) {
-	if (list.allowAll) return true;
-	if (candidate.id && list.ids.has(candidate.id)) return true;
-	if (params?.allowNameMatching === true) {
-		if (resolveDiscordAllowListNameMatch(list, candidate)) return true;
-	}
-	return false;
-}
-function resolveDiscordAllowListMatch(params) {
-	const { allowList, candidate } = params;
-	if (allowList.allowAll) return {
-		allowed: true,
-		matchKey: "*",
-		matchSource: "wildcard"
-	};
-	if (candidate.id && allowList.ids.has(candidate.id)) return {
-		allowed: true,
-		matchKey: candidate.id,
-		matchSource: "id"
-	};
-	if (params.allowNameMatching === true) {
-		const namedMatch = resolveDiscordAllowListNameMatch(allowList, candidate);
-		if (namedMatch) return {
-			allowed: true,
-			...namedMatch
-		};
-	}
-	return { allowed: false };
-}
-function resolveDiscordUserAllowed(params) {
-	const allowList = normalizeDiscordAllowList(params.allowList, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	if (!allowList) return true;
-	return allowListMatches(allowList, {
-		id: params.userId,
-		name: params.userName,
-		tag: params.userTag
-	}, { allowNameMatching: params.allowNameMatching });
-}
-function resolveDiscordRoleAllowed(params) {
-	const allowList = normalizeDiscordAllowList(params.allowList, ["role:"]);
-	if (!allowList) return true;
-	if (allowList.allowAll) return true;
-	return params.memberRoleIds.some((roleId) => allowList.ids.has(roleId));
-}
-function resolveDiscordMemberAllowed(params) {
-	const hasUserRestriction = Array.isArray(params.userAllowList) && params.userAllowList.length > 0;
-	const hasRoleRestriction = Array.isArray(params.roleAllowList) && params.roleAllowList.length > 0;
-	if (!hasUserRestriction && !hasRoleRestriction) return true;
-	const userOk = hasUserRestriction ? resolveDiscordUserAllowed({
-		allowList: params.userAllowList,
-		userId: params.userId,
-		userName: params.userName,
-		userTag: params.userTag,
-		allowNameMatching: params.allowNameMatching
-	}) : false;
-	const roleOk = hasRoleRestriction ? resolveDiscordRoleAllowed({
-		allowList: params.roleAllowList,
-		memberRoleIds: params.memberRoleIds
-	}) : false;
-	return userOk || roleOk;
-}
-function resolveDiscordMemberAccessState(params) {
-	const channelUsers = params.channelConfig?.users ?? params.guildInfo?.users;
-	const channelRoles = params.channelConfig?.roles ?? params.guildInfo?.roles;
-	return {
-		channelUsers,
-		channelRoles,
-		hasAccessRestrictions: Array.isArray(channelUsers) && channelUsers.length > 0 || Array.isArray(channelRoles) && channelRoles.length > 0,
-		memberAllowed: resolveDiscordMemberAllowed({
-			userAllowList: channelUsers,
-			roleAllowList: channelRoles,
-			memberRoleIds: params.memberRoleIds,
-			userId: params.sender.id,
-			userName: params.sender.name,
-			userTag: params.sender.tag,
-			allowNameMatching: params.allowNameMatching
-		})
-	};
-}
-function resolveDiscordOwnerAllowFrom(params) {
-	const rawAllowList = params.channelConfig?.users ?? params.guildInfo?.users;
-	if (!Array.isArray(rawAllowList) || rawAllowList.length === 0) return;
-	const allowList = normalizeDiscordAllowList(rawAllowList, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	if (!allowList) return;
-	const match = resolveDiscordAllowListMatch({
-		allowList,
-		candidate: {
-			id: params.sender.id,
-			name: params.sender.name,
-			tag: params.sender.tag
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	if (!match.allowed || !match.matchKey || match.matchKey === "*") return;
-	return [match.matchKey];
-}
-function resolveDiscordOwnerAccess(params) {
-	const ownerAllowList = normalizeDiscordAllowList(params.allowFrom?.filter((entry) => (normalizeOptionalString(entry) ?? "") !== "*"), DISCORD_OWNER_ALLOWLIST_PREFIXES);
-	return {
-		ownerAllowList,
-		ownerAllowed: ownerAllowList !== null && allowListMatches(ownerAllowList, params.sender, { allowNameMatching: params.allowNameMatching })
-	};
-}
-function resolveDiscordCommandAuthorized(params) {
-	if (!params.isDirectMessage) return true;
-	const allowList = normalizeDiscordAllowList(params.allowFrom, [
-		"discord:",
-		"user:",
-		"pk:"
-	]);
-	if (!allowList) return true;
-	return allowListMatches(allowList, {
-		id: params.author.id,
-		name: params.author.username,
-		tag: formatDiscordUserTag(params.author)
-	}, { allowNameMatching: params.allowNameMatching });
-}
-function resolveDiscordGuildEntry(params) {
-	const guild = params.guild;
-	const entries = params.guildEntries;
-	const guildId = params.guildId?.trim() || guild?.id;
-	if (!entries) return null;
-	const byId = guildId ? entries[guildId] : void 0;
-	if (byId) return {
-		...byId,
-		id: guildId
-	};
-	if (!guild) return null;
-	const slug = normalizeDiscordSlug(guild.name ?? "");
-	const bySlug = entries[slug];
-	if (bySlug) return {
-		...bySlug,
-		id: guildId ?? guild.id,
-		slug: slug || bySlug.slug
-	};
-	const wildcard = entries["*"];
-	if (wildcard) return {
-		...wildcard,
-		id: guildId ?? guild.id,
-		slug: slug || wildcard.slug
-	};
-	return null;
-}
-function buildDiscordChannelKeys(params) {
-	const allowNameMatch = params.allowNameMatch !== false;
-	return buildChannelKeyCandidates(params.id, allowNameMatch ? params.slug : void 0, allowNameMatch ? params.name : void 0);
-}
-function resolveDiscordChannelEntryMatch(channels, params, parentParams) {
-	const keys = buildDiscordChannelKeys(params);
-	const parentKeys = parentParams ? buildDiscordChannelKeys(parentParams) : void 0;
-	return resolveChannelEntryMatchWithFallback({
-		entries: channels,
-		keys,
-		parentKeys,
-		wildcardKey: "*"
-	});
-}
-function hasConfiguredDiscordChannels(channels) {
-	return Boolean(channels && Object.keys(channels).length > 0);
-}
-function resolveDiscordChannelConfigEntry(entry) {
-	return {
-		allowed: entry.enabled !== false,
-		requireMention: entry.requireMention,
-		ignoreOtherMentions: entry.ignoreOtherMentions,
-		skills: entry.skills,
-		enabled: entry.enabled,
-		users: entry.users,
-		roles: entry.roles,
-		systemPrompt: entry.systemPrompt,
-		includeThreadStarter: entry.includeThreadStarter,
-		autoThread: entry.autoThread,
-		autoThreadName: entry.autoThreadName,
-		autoArchiveDuration: entry.autoArchiveDuration
-	};
-}
-function resolveDiscordChannelConfig(params) {
-	const { guildInfo, channelId, channelName, channelSlug } = params;
-	const channels = guildInfo?.channels;
-	if (!hasConfiguredDiscordChannels(channels)) return null;
-	const match = resolveDiscordChannelEntryMatch(channels, {
-		id: channelId,
-		name: channelName,
-		slug: channelSlug
-	});
-	return resolveChannelMatchConfig(match, resolveDiscordChannelConfigEntry) ?? { allowed: false };
-}
-function resolveDiscordChannelConfigWithFallback(params) {
-	const { guildInfo, channelId, channelName, channelSlug, parentId, parentName, parentSlug, scope } = params;
-	const channels = guildInfo?.channels;
-	if (!hasConfiguredDiscordChannels(channels)) return null;
-	const resolvedParentSlug = parentSlug ?? (parentName ? normalizeDiscordSlug(parentName) : "");
-	const match = resolveDiscordChannelEntryMatch(channels, {
-		id: channelId,
-		name: channelName,
-		slug: channelSlug,
-		allowNameMatch: scope !== "thread"
-	}, parentId || parentName || parentSlug ? {
-		id: parentId ?? "",
-		name: parentName,
-		slug: resolvedParentSlug
-	} : void 0);
-	return resolveChannelMatchConfig(match, resolveDiscordChannelConfigEntry) ?? { allowed: false };
-}
-function resolveDiscordShouldRequireMention(params) {
-	if (!params.isGuildMessage) return false;
-	if (params.isAutoThreadOwnedByBot ?? isDiscordAutoThreadOwnedByBot(params)) return false;
-	return params.channelConfig?.requireMention ?? params.guildInfo?.requireMention ?? true;
-}
-function isDiscordAutoThreadOwnedByBot(params) {
-	if (!params.isThread) return false;
-	if (!params.channelConfig?.autoThread) return false;
-	const botId = params.botId?.trim();
-	const threadOwnerId = params.threadOwnerId?.trim();
-	return Boolean(botId && threadOwnerId && botId === threadOwnerId);
-}
-function isDiscordGroupAllowedByPolicy(params) {
-	if (params.groupPolicy === "allowlist" && !params.guildAllowlisted) return false;
-	if (params.groupPolicy === "disabled") return false;
-	return params.groupPolicy !== "allowlist" || !params.channelAllowlistConfigured || params.channelAllowed;
-}
-function resolveDiscordChannelPolicyCommandAuthorizer(params) {
-	const channelAllowlistConfigured = Boolean(params.guildInfo?.channels) && Object.keys(params.guildInfo?.channels ?? {}).length > 0;
-	return {
-		configured: params.groupPolicy === "allowlist" && (Boolean(params.guildInfo) || channelAllowlistConfigured),
-		allowed: isDiscordGroupAllowedByPolicy({
-			groupPolicy: params.groupPolicy,
-			guildAllowlisted: Boolean(params.guildInfo),
-			channelAllowlistConfigured,
-			channelAllowed: params.channelConfig?.allowed !== false
-		})
-	};
-}
-function resolveGroupDmAllow(params) {
-	const { channels, channelId, channelName, channelSlug } = params;
-	if (!channels || channels.length === 0) return true;
-	return resolveAllowlistMatchByCandidates({
-		allowList: channels.map((entry) => normalizeDiscordSlug(entry)),
-		candidates: [
-			{
-				value: normalizeDiscordSlug(channelId),
-				source: "id"
-			},
-			{
-				value: channelSlug,
-				source: "slug"
-			},
-			{
-				value: channelName ? normalizeDiscordSlug(channelName) : void 0,
-				source: "name"
-			}
-		]
-	}).allowed;
-}
-function shouldEmitDiscordReactionNotification(params) {
-	const mode = params.mode ?? "own";
-	if (mode === "off") return false;
-	const accessGuildInfo = params.guildInfo ?? (params.allowlist ? { users: params.allowlist } : null);
-	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
-		channelConfig: params.channelConfig,
-		guildInfo: accessGuildInfo,
-		memberRoleIds: params.memberRoleIds ?? [],
-		sender: {
-			id: params.userId,
-			name: params.userName,
-			tag: params.userTag
-		},
-		allowNameMatching: params.allowNameMatching
-	});
-	if (mode === "allowlist") return hasAccessRestrictions && memberAllowed;
-	if (hasAccessRestrictions && !memberAllowed) return false;
-	if (mode === "all") return true;
-	if (mode === "own") return Boolean(params.botId && params.messageAuthorId === params.botId);
-	return false;
-}
-//#endregion
-export { resolveTimestampMs as S, resolveGroupDmAllow as _, normalizeDiscordSlug as a, formatDiscordUserTag as b, resolveDiscordChannelConfigWithFallback as c, resolveDiscordGuildEntry as d, resolveDiscordMemberAccessState as f, resolveDiscordShouldRequireMention as g, resolveDiscordOwnerAllowFrom as h, normalizeDiscordDisplaySlug as i, resolveDiscordChannelPolicyCommandAuthorizer as l, resolveDiscordOwnerAccess as m, isDiscordGroupAllowedByPolicy as n, resolveDiscordAllowListMatch as o, resolveDiscordMemberAllowed as p, normalizeDiscordAllowList as r, resolveDiscordChannelConfig as s, allowListMatches as t, resolveDiscordCommandAuthorized as u, shouldEmitDiscordReactionNotification as v, resolveDiscordSystemLocation as x, formatDiscordReactionEmoji as y };

package/dist/api-BfmEP6wp.js

@@ -1,161 +0,0 @@
-import { t as parseDiscordRetryAfterBodySeconds } from "./retry-after-BrLjLUJi.js";
-import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
-import { parseRetryAfterHeaderSeconds, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-import { readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-import { resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
-import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-//#region extensions/discord/src/error-body.ts
-const DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS = 240;
-function summarizeDiscordResponseBody(body, opts = {}) {
-	const summary = body.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/\s+/g, " ").trim();
-	if (!summary) return opts.emptyText;
-	return truncateUtf16Safe(redactToolPayloadText(summary), DISCORD_RESPONSE_BODY_SUMMARY_MAX_CHARS);
-}
-function isDiscordHtmlResponseBody(body, contentType) {
-	return /\bhtml\b/i.test(contentType ?? "") || /^\s*<!doctype\s+html\b/i.test(body) || /^\s*<html\b/i.test(body);
-}
-function isDiscordRateLimitResponseBody(body) {
-	const normalized = body.toLowerCase();
-	return normalized.includes("error 1015") || normalized.includes("cloudflare") || normalized.includes("rate limit");
-}
-//#endregion
-//#region extensions/discord/src/api.ts
-const DISCORD_API_BASE = "https://discord.com/api/v10";
-const DISCORD_API_RETRY_DEFAULTS = {
-	attempts: 3,
-	minDelayMs: 500,
-	maxDelayMs: 3e5,
-	jitter: .1
-};
-const DISCORD_API_429_FALLBACK_RETRY_AFTER_SECONDS = 60;
-const DISCORD_API_ERROR_BODY_LIMIT_BYTES = 8192;
-const DISCORD_API_RESPONSE_BODY_LIMIT_BYTES = 4194304;
-const DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS = 1e4;
-function parseDiscordApiErrorPayload(text) {
-	const trimmed = text.trim();
-	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
-	try {
-		const payload = JSON.parse(trimmed);
-		if (payload && typeof payload === "object") return payload;
-	} catch {
-		return null;
-	}
-	return null;
-}
-function parseRetryAfterSeconds(text, response) {
-	const payload = parseDiscordApiErrorPayload(text);
-	const retryAfter = parseDiscordRetryAfterBodySeconds(payload?.retry_after);
-	if (retryAfter !== void 0) return retryAfter;
-	const header = response.headers.get("Retry-After");
-	if (!header) return;
-	return parseRetryAfterHeaderSeconds(header);
-}
-function formatRetryAfterSeconds(value) {
-	if (value === void 0 || !Number.isFinite(value) || value < 0) return;
-	return `${value < 10 ? value.toFixed(1) : Math.round(value).toString()}s`;
-}
-function formatDiscordApiErrorTextUntrusted(text, response) {
-	const trimmed = text.trim();
-	if (!trimmed) return;
-	const payload = parseDiscordApiErrorPayload(trimmed);
-	if (!payload) {
-		if (trimmed.startsWith("{") && trimmed.endsWith("}")) return "unknown error";
-		const summary = summarizeDiscordResponseBody(trimmed);
-		if (isDiscordHtmlResponseBody(trimmed, response.headers.get("content-type"))) {
-			if (!summary) return response.status === 429 ? "rate limited by Discord upstream" : void 0;
-			return response.status === 429 ? `rate limited by Discord upstream: ${summary}` : summary;
-		}
-		return summary;
-	}
-	const message = typeof payload.message === "string" && payload.message.trim() ? payload.message.trim() : "unknown error";
-	const retryAfter = formatRetryAfterSeconds(parseDiscordRetryAfterBodySeconds(payload.retry_after));
-	return retryAfter ? `${message} (retry after ${retryAfter})` : message;
-}
-function formatDiscordApiErrorText(text, response) {
-	const detail = formatDiscordApiErrorTextUntrusted(text, response);
-	return detail ? redactToolPayloadText(detail) : detail;
-}
-var DiscordApiError = class extends Error {
-	constructor(message, status, retryAfter) {
-		super(message);
-		this.status = status;
-		this.retryAfter = retryAfter;
-	}
-};
-function getDiscordApiRetryAfterMs(err, retryConfig) {
-	if (!(err instanceof DiscordApiError) || typeof err.retryAfter !== "number") return;
-	return Math.min(Math.max(0, err.retryAfter * 1e3), retryConfig.maxDelayMs);
-}
-function normalizeDiscordRequestBody(body, headers) {
-	if (body === void 0) return;
-	if (typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer) return body;
-	headers.set("Content-Type", headers.get("Content-Type") ?? "application/json");
-	return JSON.stringify(body);
-}
-function createDiscordRequestSignal(options) {
-	if (typeof options.timeoutMs !== "number" || options.signal?.aborted) return {
-		signal: options.signal,
-		cleanup: () => void 0
-	};
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), resolveTimerTimeoutMs(options.timeoutMs, 1));
-	timeout.unref?.();
-	return {
-		signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal,
-		cleanup: () => clearTimeout(timeout)
-	};
-}
-async function requestDiscord(path, token, options) {
-	const fetchImpl = resolveFetch(options?.fetcher ?? fetch);
-	if (!fetchImpl) throw new Error("fetch is not available");
-	const retryConfig = resolveRetryConfig(DISCORD_API_RETRY_DEFAULTS, options?.retry);
-	return retryAsync(async () => {
-		const headers = new Headers(options?.headers);
-		headers.set("Authorization", `Bot ${token}`);
-		const body = normalizeDiscordRequestBody(options?.body, headers);
-		const requestSignal = createDiscordRequestSignal(options ?? {});
-		try {
-			const res = await fetchImpl(`${DISCORD_API_BASE}${path}`, {
-				method: options?.method ?? (body === void 0 ? "GET" : "POST"),
-				headers,
-				body,
-				signal: requestSignal.signal
-			});
-			if (!res.ok) {
-				const text = await readResponseTextLimited(res, DISCORD_API_ERROR_BODY_LIMIT_BYTES).catch(() => "");
-				const detail = formatDiscordApiErrorText(text, res);
-				const suffix = detail ? `: ${detail}` : "";
-				const retryAfter = res.status === 429 ? parseRetryAfterSeconds(text, res) ?? DISCORD_API_429_FALLBACK_RETRY_AFTER_SECONDS : void 0;
-				throw new DiscordApiError(`Discord API ${path} failed (${res.status})${suffix}`, res.status, retryAfter);
-			}
-			const responseBody = await readResponseWithLimit(res, DISCORD_API_RESPONSE_BODY_LIMIT_BYTES, { onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`Discord API ${path} response body too large: ${size} bytes (limit: ${maxBytes} bytes)`) });
-			try {
-				const text = new TextDecoder("utf-8", { fatal: true }).decode(responseBody);
-				if (!text.trim()) return;
-				return JSON.parse(text);
-			} catch {
-				throw new DiscordApiError(`Discord API ${path} returned malformed JSON`, 0);
-			}
-		} finally {
-			requestSignal.cleanup();
-		}
-	}, {
-		...retryConfig,
-		label: options?.label ?? path,
-		shouldRetry: (err) => err instanceof DiscordApiError && err.status === 429,
-		retryAfterMs: (err) => getDiscordApiRetryAfterMs(err, retryConfig),
-		sleep: (ms) => sleepWithAbort(ms, options?.signal)
-	});
-}
-async function fetchDiscord(path, token, fetcher = fetch, options) {
-	return await requestDiscord(path, token, {
-		...options,
-		fetcher,
-		method: "GET"
-	});
-}
-//#endregion
-export { isDiscordRateLimitResponseBody as a, requestDiscord as i, DiscordApiError as n, summarizeDiscordResponseBody as o, fetchDiscord as r, DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS as t };