@elizaos/plugin-discord 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/service.d.ts

@@ -0,0 +1,403 @@
+import { ChannelType, type Character, type Content, type IAgentRuntime, type Media, type Memory, Service, type TargetInfo } from "@elizaos/core";
+/**
+ * IMPORTANT: Discord ID Handling - Why stringToUuid() instead of asUUID()
+ *
+ * Discord uses "snowflake" IDs - large 64-bit integers represented as strings
+ * (e.g., "1253563208833433701"). These are NOT valid UUIDs.
+ *
+ * UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12 hex digits with dashes)
+ * Discord ID:  1253563208833433701 (plain number string)
+ *
+ * The two UUID-related functions behave differently:
+ *
+ * - `asUUID(str)` - VALIDATES that the string is already a valid UUID format.
+ *   If not, it throws: "Error: Invalid UUID format: 1253563208833433701"
+ *   Use only when you're certain the input is already a valid UUID.
+ *
+ * - `stringToUuid(str)` - CONVERTS any string into a deterministic UUID by hashing it.
+ *   Always succeeds. The same input always produces the same UUID output.
+ *   Use this for Discord snowflake IDs.
+ *
+ * When working with Discord IDs in ElizaOS:
+ *
+ * 1. `stringToUuid(discordId)` - For storing Discord IDs in UUID fields (e.g., `messageServerId`).
+ *
+ * 2. `createUniqueUuid(runtime, discordId)` - For `worldId` and `roomId`. This adds the agent's
+ *    ID to the hash, ensuring each agent has its own unique namespace for the same Discord server.
+ *
+ * 3. `messageServerId` - The correct property name for server IDs on Room and World objects.
+ *
+ * 4. Discord-specific events (e.g., DiscordEventTypes.VOICE_STATE_UPDATE) are not in core's
+ *    EventPayloadMap. When emitting these events, cast to `string[]` and payload to `any`
+ *    to use the generic emitEvent overload.
+ */
+import { type Channel, Client as DiscordJsClient, type Message } from "discord.js";
+import { type ICompatRuntime } from "./compat";
+import { MessageManager } from "./messages";
+import { type ChannelHistoryOptions, type ChannelHistoryResult, type IDiscordService } from "./types";
+import { VoiceManager } from "./voice";
+/**
+ * DiscordService class representing a service for interacting with Discord.
+ * @extends Service
+ * @implements IDiscordService
+ * @property {string} serviceType - The type of service, set to DISCORD_SERVICE_NAME.
+ * @property {string} capabilityDescription - A description of the service's capabilities.
+ * @property {DiscordJsClient} client - The DiscordJsClient used for communication.
+ * @property {Character} character - The character associated with the service.
+ * @property {MessageManager} messageManager - The manager for handling messages.
+ * @property {VoiceManager} voiceManager - The manager for handling voice communication.
+ */
+export declare class DiscordService extends Service implements IDiscordService {
+    protected runtime: ICompatRuntime;
+    static serviceType: string;
+    capabilityDescription: string;
+    client: DiscordJsClient | null;
+    character: Character;
+    messageManager?: MessageManager;
+    voiceManager?: VoiceManager;
+    private discordSettings;
+    private userSelections;
+    private timeouts;
+    clientReadyPromise: Promise<void> | null;
+    private slashCommands;
+    private commandRegistrationQueue;
+    /**
+     * Slash command names that should bypass allowed channel restrictions.
+     */
+    private allowAllSlashCommands;
+    /**
+     * List of allowed channel IDs (parsed from CHANNEL_IDS env var).
+     * If undefined, all channels are allowed.
+     */
+    private allowedChannelIds?;
+    /**
+     * Set of dynamically added channel IDs through joinChannel action.
+     * These are merged with allowedChannelIds for runtime channel management.
+     */
+    private dynamicChannelIds;
+    /**
+     * Constructor for Discord client.
+     * Initializes the Discord client with specified intents and partials,
+     * sets up event listeners, and ensures all servers exist.
+     *
+     * @param {IAgentRuntime} runtime - The AgentRuntime instance
+     */
+    constructor(runtime: IAgentRuntime);
+    static start(runtime: IAgentRuntime): Promise<DiscordService>;
+    /**
+     * The SendHandlerFunction implementation for Discord.
+     * @param {IAgentRuntime} runtime - The runtime instance.
+     * @param {TargetInfo} target - The target information for the message.
+     * @param {Content} content - The content of the message to send.
+     * @returns {Promise<void>} A promise that resolves when the message is sent or rejects on error.
+     * @throws {Error} If the client is not ready, target is invalid, or sending fails.
+     */
+    handleSendMessage(runtime: IAgentRuntime, target: TargetInfo, content: Content): Promise<void>;
+    /**
+     * Set up event listeners for the client.
+     * @private
+     */
+    private setupEventListeners;
+    /**
+     * Handles the event when a new member joins a guild.
+     *
+     * **Event Design Note:**
+     * We intentionally do NOT emit the standardized `EventType.ENTITY_JOINED` here.
+     * In ElizaOS's abstraction model:
+     * - A Discord "guild" maps to a "world" (the server/community)
+     * - A Discord "channel" maps to a "room" (a specific conversation space)
+     *
+     * `EventType.ENTITY_JOINED` requires a `roomId` because the bootstrap plugin's
+     * handler calls `syncSingleUser()` to sync the entity to a specific room. When
+     * a member joins a guild, they've joined the "world" but haven't joined any
+     * specific "room" yet - they're just a potential participant.
+     *
+     * The entity will be properly synced to rooms when they first interact:
+     * - First message in a channel → message handler calls `ensureConnection()`
+     * - Joining a voice channel → voice handler syncs them to that room
+     *
+     * We still emit the Discord-specific `DiscordEventTypes.ENTITY_JOINED` so that
+     * Discord-aware plugins can react to guild member joins (e.g., welcome messages,
+     * role assignment, moderation checks).
+     *
+     * @param {GuildMember} member - The GuildMember object representing the new member.
+     * @returns {Promise<void>} - A Promise that resolves once the event handling is complete.
+     * @private
+     */
+    private handleGuildMemberAdd;
+    /**
+     * Registers slash commands with Discord.
+     *
+     * This method uses a hybrid permission system that combines:
+     * 1. Discord's native permission features (default_member_permissions, contexts)
+     * 2. ElizaOS channel whitelist bypass (bypassChannelWhitelist flag)
+     * 3. Custom validation functions (validator callback)
+     *
+     * ## Design Decisions
+     *
+     * ### Why Hybrid Approach?
+     * - Discord's native permissions are powerful but limited to role-based access
+     * - ElizaOS needs programmatic control for channel restrictions and custom logic
+     * - Combining both gives developers the best of both worlds
+     *
+     * ### Why Transform Simple Flags?
+     * - Developer experience: `guildOnly: true` is clearer than `contexts: [0]`
+     * - Abstraction: Shields developers from Discord API changes
+     * - Sensible defaults: Zero config should "just work"
+     *
+     * ### Why Three Registration Categories?
+     *
+     * Commands are categorized based on where they should be available:
+     *
+     * 1. **Global commands** (no guildOnly, no guildIds):
+     *    - Registered globally via `application.commands.set()` for DM access
+     *    - ALSO registered per-guild for instant availability in guilds
+     *    - Guild version overrides global (no duplicates shown in Discord)
+     *    - Best of both worlds: instant in guilds + works in DMs
+     *
+     * 2. **Guild-only commands** (guildOnly: true or contexts: [0]):
+     *    - Registered per-guild via `application.commands.set(cmds, guildId)`
+     *    - NOT available in DMs (correct behavior)
+     *    - Instant availability in guilds
+     *    - New guilds get commands via guildCreate event
+     *
+     * 3. **Targeted commands** (has guildIds array):
+     *    - Registered only to specified guilds via `.create()` or `.edit()`
+     *    - Useful for testing or server-specific features
+     *    - Instant updates
+     *
+     * ### Why Register Global Commands Both Globally AND Per-Guild?
+     * - Global registration alone takes up to 1 hour to propagate (Discord limitation)
+     * - Per-guild registration gives instant availability
+     * - Guild commands override global ones in that guild (no duplicates)
+     * - Global registration still needed for DM access (no guild context in DMs)
+     *
+     * ### Why Not Register Everything Per-Guild Only?
+     * - Commands that work in DMs MUST be registered globally
+     * - There's no guild context in DMs, so per-guild commands don't appear there
+     *
+     * @param commands - Array of slash commands to register
+     * @returns Promise that resolves when registration is complete
+     * @private
+     */
+    private registerSlashCommands;
+    /**
+     * Transforms an ElizaOS slash command to Discord API format.
+     * This bridges our developer-friendly API with Discord's native requirements.
+     * @param {DiscordSlashCommand} cmd - The ElizaOS command definition
+     * @returns {object} Discord API compatible command object
+     * @private
+     */
+    private transformCommandToDiscordApi;
+    /**
+     * Checks if a command is guild-only (shouldn't appear in DMs).
+     *
+     * A command is considered guild-only if:
+     * - `contexts: [0]` is set (Discord's native format, where 0 = Guild only)
+     * - `guildOnly: true` is set AND no contexts override is provided
+     *
+     * `contexts` takes precedence over `guildOnly` to be consistent with
+     * `transformCommandToDiscordApi`. { guildOnly: true, contexts: [0, 1] }
+     * will correctly enable DM access (not be treated as guild-only).
+     *
+     * @param {DiscordSlashCommand} cmd - The command to check
+     * @returns {boolean} True if the command should only be available in guilds
+     * @private
+     */
+    private isGuildOnlyCommand;
+    /**
+     * Handles the event when the bot joins a guild. It logs the guild name, fetches additional information about the guild, scans the guild for voice data, creates standardized world data structure, generates unique IDs, and emits events to the runtime.
+     * @param {Guild} guild - The guild that the bot has joined.
+     * @returns {Promise<void>} A promise that resolves when the guild creation is handled.
+     * @private
+     */
+    private handleGuildCreate;
+    /**
+     * Handles interactions created by the user, specifically commands and message components.
+     * @param {Interaction} interaction - The interaction object received.
+     * @returns {Promise<void>} A promise that resolves when the interaction is handled.
+     * @private
+     */
+    private handleInteractionCreate;
+    /**
+     * Builds a standardized list of rooms from Discord guild channels.
+     *
+     * @param {Guild} guild The guild to build rooms for.
+     * @param {UUID} _worldId The ID of the world to associate with the rooms (currently unused in favor of direct channel to room mapping).
+     * @returns {Promise<Array<{ id: UUID; name: string; type: ChannelType; channelId: string; participants: UUID[] }>>} An array of standardized room objects.
+     * @private
+     */
+    private buildStandardizedRooms;
+    /**
+     * Builds a standardized list of users (entities) from Discord guild members.
+     * Implements different strategies based on guild size for performance.
+     *
+     * @param {Guild} guild - The guild from which to build the user list.
+     * @returns {Promise<Entity[]>} A promise that resolves with an array of standardized entity objects.
+     * @private
+     */
+    private buildStandardizedUsers;
+    /**
+     * Handles tasks to be performed once the Discord client is fully ready and connected.
+     * This includes fetching guilds, scanning for voice data, and emitting connection events.
+     * @private
+     * @returns {Promise<void>} A promise that resolves when all on-ready tasks are completed.
+     */
+    private onReady;
+    /**
+     * Registers send handlers for the Discord service instance.
+     * This allows the runtime to correctly dispatch messages to this service.
+     * @param {IAgentRuntime} runtime - The agent runtime instance.
+     * @param {DiscordService} serviceInstance - The instance of the DiscordService.
+     * @static
+     */
+    static registerSendHandlers(runtime: IAgentRuntime, serviceInstance: DiscordService): void;
+    /**
+     * Fetches all members who have access to a specific text channel.
+     *
+     * @param {string} channelId - The Discord ID of the text channel.
+     * @param {boolean} [useCache=true] - Whether to prioritize cached data. Defaults to true.
+     * @returns {Promise<Array<{id: string, username: string, displayName: string}>>} A promise that resolves with an array of channel member objects, each containing id, username, and displayName.
+     */
+    getTextChannelMembers(channelId: string, useCache?: boolean): Promise<Array<{
+        id: string;
+        username: string;
+        displayName: string;
+    }>>;
+    /**
+     * Fetches the topic/description of a Discord text channel.
+     *
+     * WHY THIS METHOD EXISTS:
+     * =======================
+     * Room metadata contains topic from initial sync, but channel topics can change.
+     * This method lets plugins fetch FRESH topic data directly from Discord API.
+     *
+     * Used by plugin-content-seeder to get authoritative topic data for discussion seeding.
+     *
+     * WHY NOT JUST USE METADATA:
+     * Room.metadata.topic is set at sync time and may be stale if the Discord admin
+     * updates the channel topic. For plugins that care about freshness, this method
+     * provides a way to get current data.
+     *
+     * TRADEOFF: This makes an API call, so it's slower than reading metadata.
+     * Use metadata for most cases, this method when freshness matters.
+     *
+     * @param {string} channelId - The Discord ID of the text channel.
+     * @returns {Promise<string | null>} The channel topic, or null if not available.
+     */
+    getChannelTopic(channelId: string): Promise<string | null>;
+    /**
+     * Generic handler for reaction events (add/remove).
+     * @private
+     */
+    private handleReaction;
+    /**
+     * Handles reaction addition.
+     * @private
+     */
+    private handleReactionAdd;
+    /**
+     * Handles reaction removal.
+     * @private
+     */
+    private handleReactionRemove;
+    /**
+     * Checks if a channel ID is allowed based on both env config and dynamic additions.
+     * @param {string} channelId - The channel ID to check
+     * @returns {boolean} Whether the channel is allowed
+     */
+    isChannelAllowed(channelId: string): boolean;
+    /**
+     * Adds a channel to the dynamic allowed list.
+     * @param {string} channelId - The channel ID to add
+     * @returns {boolean} Whether the channel was successfully added
+     */
+    addAllowedChannel(channelId: string): boolean;
+    /**
+     * Removes a channel from the dynamic allowed list.
+     * @param {string} channelId - The channel ID to remove
+     * @returns {boolean} Whether the channel was in the list and removed
+     */
+    removeAllowedChannel(channelId: string): boolean;
+    /**
+     * Gets the list of all allowed channels (env + dynamic).
+     * @returns {string[]} Array of allowed channel IDs
+     */
+    getAllowedChannels(): string[];
+    /**
+     * Type guard to check if a channel is a guild text-based channel
+     * @private
+     */
+    private isGuildTextBasedChannel;
+    /**
+     * Helper to delay execution
+     * @private
+     */
+    private delay;
+    /**
+     * Get spider state for a channel from the database
+     * @private
+     */
+    private getSpiderState;
+    /**
+     * Save spider state for a channel to the database
+     * @private
+     */
+    private saveSpiderState;
+    /**
+     * Fetches and persists message history from a Discord channel.
+     * Supports pagination, state tracking, and streaming via callback.
+     *
+     * Persistence behavior:
+     * - When `onBatch` callback is NOT provided: Messages are automatically persisted
+     *   to the database and accumulated in the returned `messages` array.
+     * - When `onBatch` callback IS provided: Messages are passed to the callback and
+     *   the caller is responsible for persistence. This allows for custom handling.
+     *
+     * @param {string} channelId - The Discord channel ID to fetch from
+     * @param {ChannelHistoryOptions} options - Options for the fetch operation
+     * @returns {Promise<ChannelHistoryResult>} The result with messages and stats
+     */
+    fetchChannelHistory(channelId: string, options?: ChannelHistoryOptions): Promise<ChannelHistoryResult>;
+    /**
+     * Builds a Memory object from a Discord Message.
+     * This is a reusable helper for converting Discord messages to ElizaOS Memory format.
+     *
+     * @param {Message} message - The Discord message to convert
+     * @param {Object} options - Optional parameters
+     * @param {string} options.processedContent - Pre-processed text content (if already processed, to avoid double-processing)
+     * @param {Media[]} options.processedAttachments - Pre-processed attachments (if already processed)
+     * @param {Object} options.extraContent - Additional content fields to merge into the memory content
+     * @param {Object} options.extraMetadata - Additional metadata fields to merge into the memory metadata
+     * @returns {Promise<Memory | null>} The Memory object, or null if the message is invalid
+     */
+    buildMemoryFromMessage(message: Message, options?: {
+        processedContent?: string;
+        processedAttachments?: Media[];
+        extraContent?: Record<string, unknown>;
+        extraMetadata?: Record<string, unknown>;
+    }): Promise<Memory | null>;
+    /**
+     * Ensures entity connections exist for a batch of Discord messages using batch API.
+     * This should be called before persisting memories to avoid FK constraint failures.
+     *
+     * @param {Message[]} messages - The Discord messages to ensure connections for
+     * @param {Set<string>} ensuredEntityIds - Optional set of already-ensured entity IDs (for caching across batches)
+     * @returns {Promise<void>}
+     */
+    private ensureConnectionsForMessages;
+    /**
+     * Stops the Discord service and cleans up resources.
+     * Implements the abstract method from the Service class.
+     */
+    stop(): Promise<void>;
+    /**
+     * Asynchronously retrieves the type of a given channel.
+     *
+     * @param {Channel} channel - The channel for which to determine the type.
+     * @returns {Promise<ChannelType>} A Promise that resolves with the type of the channel.
+     */
+    getChannelType(channel: Channel): Promise<ChannelType>;
+}
+export default DiscordService;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../service.ts"],"names":[],"mappings":"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"}

package/dist/test-setup.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=test-setup.d.ts.map

package/dist/test-setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-setup.d.ts","sourceRoot":"","sources":["../test-setup.ts"],"names":[],"mappings":""}

package/dist/tests.d.ts

@@ -0,0 +1,123 @@
+import type { Readable } from "node:stream";
+import { type VoiceConnection } from "@discordjs/voice";
+import { type IAgentRuntime, type TestSuite } from "@elizaos/core";
+import { AttachmentBuilder, type Guild, type TextChannel } from "discord.js";
+import type { DiscordService } from "./service";
+/**
+ * Represents a test suite for Discord functionality.
+ * @class DiscordTestSuite
+ * @implements TestSuite
+ * @property {string} name - The name of the test suite
+ * @property {DiscordService | null} discordClient - The Discord client instance
+ * @property {Array<{ name: string; fn: (runtime: IAgentRuntime) => Promise<void> }>} tests - Array of test functions
+ */
+export declare class DiscordTestSuite implements TestSuite {
+    name: string;
+    private discordClient;
+    tests: {
+        name: string;
+        fn: (runtime: IAgentRuntime) => Promise<void>;
+    }[];
+    /**
+     * Constructor for initializing the tests array with test cases to be executed.
+     *
+     * @constructor
+     * @this {TestSuite}
+     */
+    constructor();
+    /**
+     * Asynchronously tests the creation of Discord client using the provided runtime.
+     *
+     * @param {IAgentRuntime} runtime - The agent runtime used to obtain the Discord service.
+     * @returns {Promise<void>} - A Promise that resolves once the Discord client is ready.
+     * @throws {Error} - If an error occurs while creating the Discord client.
+     */
+    testCreatingDiscordClient(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously tests the join voice slash command functionality.
+     *
+     * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+     * @returns {Promise<void>} - A promise that resolves once the test is complete.
+     * @throws {Error} - If there is an error in executing the slash command test.
+     */
+    testJoinVoiceSlashCommand(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously tests the leave voice channel slash command.
+     *
+     * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+     * @returns {Promise<void>} A promise that resolves when the test is complete.
+     */
+    testLeaveVoiceSlashCommand(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Test Text to Speech playback.
+     * @param {IAgentRuntime} runtime - The Agent Runtime instance.
+     * @throws {Error} - If voice channel is invalid, voice connection fails to become ready, or no text to speech service found.
+     */
+    testTextToSpeechPlayback(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously tests sending a text message to a specified channel.
+     *
+     * @param {IAgentRuntime} runtime - The runtime for the agent.
+     * @returns {Promise<void>} A Promise that resolves when the message is sent successfully.
+     * @throws {Error} If there is an error in sending the text message.
+     */
+    testSendingTextMessage(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously handles sending a test message using the given runtime and mock user data.
+     *
+     * @param {IAgentRuntime} runtime - The agent runtime object.
+     * @returns {Promise<void>} A Promise that resolves once the message is handled.
+     */
+    testHandlingMessage(runtime: IAgentRuntime): Promise<void>;
+    /**
+     * Asynchronously retrieves the test channel associated with the provided runtime.
+     *
+     * @param {IAgentRuntime} runtime - The runtime object containing necessary information.
+     * @returns {Promise<Channel>} The test channel retrieved from the Discord client.
+     * @throws {Error} If no test channel is found.
+     */
+    getTestChannel(runtime: IAgentRuntime): Promise<import("discord.js").Channel>;
+    /**
+     * Async function to send a message to a text-based channel.
+     *
+     * @param {TextChannel} channel - The text-based channel the message is being sent to.
+     * @param {string} messageContent - The content of the message being sent.
+     * @param {AttachmentBuilder[]} files - An array of files to include in the message.
+     * @throws {Error} If the channel is not a text-based channel or does not exist.
+     * @throws {Error} If there is an error sending the message.
+     */
+    sendMessageToChannel(channel: TextChannel, messageContent: string, files: AttachmentBuilder[]): Promise<void>;
+    /**
+     * Play an audio stream from a given response stream using the provided VoiceConnection.
+     *
+     * @param responseStream - The response stream to play as audio.
+     * @param connection - The VoiceConnection to use for playing the audio.
+     * @returns A Promise that resolves when the TTS playback is finished.
+     */
+    playAudioStream(responseStream: ReadableStream | NodeJS.ReadableStream | Readable, connection: VoiceConnection): Promise<void>;
+    /**
+     * Retrieves the active guild where the bot is currently connected to a voice channel.
+     *
+     * @param {DiscordService} discordClient The DiscordService instance used to interact with the Discord API.
+     * @returns {Promise<Guild>} The active guild where the bot is currently connected to a voice channel.
+     * @throws {Error} If no active voice connection is found for the bot.
+     */
+    getActiveGuild(discordClient: DiscordService): Promise<Guild>;
+    /**
+     * Waits for the VoiceManager in the Discord client to be ready.
+     *
+     * @param {DiscordService} discordClient - The Discord client to check for VoiceManager readiness.
+     * @throws {Error} If the Discord client is not initialized.
+     * @returns {Promise<void>} A promise that resolves when the VoiceManager is ready.
+     */
+    private waitForVoiceManagerReady;
+    /**
+     * Validates the Discord test channel ID by checking if it is set in the runtime or environment variables.
+     * If the test channel ID is not set, an error is thrown.
+     *
+     * @param {IAgentRuntime} runtime The runtime object containing the settings and environment variables.
+     * @returns {string} The validated Discord test channel ID.
+     */
+    private validateChannelId;
+}
+//# sourceMappingURL=tests.d.ts.map

package/dist/tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../tests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAMN,KAAK,eAAe,EAEpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACN,KAAK,aAAa,EAGlB,KAAK,SAAS,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,EACN,iBAAiB,EAGjB,KAAK,KAAK,EAEV,KAAK,WAAW,EAChB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAOhD;;;;;;;GAOG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IACjD,IAAI,SAAa;IACjB,OAAO,CAAC,aAAa,CAAkB;IACvC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,EAAE,CAAC;IAEzE;;;;;OAKG;;IA8BH;;;;;;OAMG;IACG,yBAAyB,CAAC,OAAO,EAAE,aAAa;IAgCtD;;;;;;OAMG;IACG,yBAAyB,CAAC,OAAO,EAAE,aAAa;IAkDtD;;;;;OAKG;IACG,0BAA0B,CAAC,OAAO,EAAE,aAAa;IAqCvD;;;;OAIG;IACG,wBAAwB,CAAC,OAAO,EAAE,aAAa;IA0DrD;;;;;;OAMG;IACG,sBAAsB,CAAC,OAAO,EAAE,aAAa;IAoBnD;;;;;OAKG;IACG,mBAAmB,CAAC,OAAO,EAAE,aAAa;IA2DhD;;;;;;OAMG;IACG,cAAc,CAAC,OAAO,EAAE,aAAa;IAgB3C;;;;;;;;OAQG;IACG,oBAAoB,CACzB,OAAO,EAAE,WAAW,EACpB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,iBAAiB,EAAE;IAqB3B;;;;;;OAMG;IACG,eAAe,CACpB,cAAc,EAAE,cAAc,GAAG,MAAM,CAAC,cAAc,GAAG,QAAQ,EACjE,UAAU,EAAE,eAAe;IA4B5B;;;;;;OAMG;IACG,cAAc,CAAC,aAAa,EAAE,cAAc;IAiBlD;;;;;;OAMG;YACW,wBAAwB;IAqBtC;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;CAWzB"}