@commandkit/ratelimit 0.0.0-dev.20260317060555

package/dist/plugin.js

@@ -0,0 +1,796 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitPlugin = void 0;
+const commandkit_1 = require("commandkit");
+const async_queue_1 = require("commandkit/async-queue");
+const discord_js_1 = require("discord.js");
+const RateLimitEngine_1 = require("./engine/RateLimitEngine");
+const config_1 = require("./utils/config");
+const keys_1 = require("./utils/keys");
+const constants_1 = require("./constants");
+const memory_1 = require("./storage/memory");
+const runtime_1 = require("./runtime");
+const configure_1 = require("./configure");
+const time_1 = require("./utils/time");
+const ANALYTICS_EVENTS = {
+    HIT: 'ratelimit_hit',
+    ALLOWED: 'ratelimit_allowed',
+    RESET: 'ratelimit_reset',
+    VIOLATION: 'ratelimit_violation',
+};
+/**
+ * Runtime plugin that enforces rate limits for CommandKit commands so handlers stay lean.
+ *
+ * @extends RuntimePlugin<RateLimitPluginOptions>
+ */
+class RateLimitPlugin extends commandkit_1.RuntimePlugin {
+    constructor(options) {
+        super(options);
+        this.name = 'RateLimitPlugin';
+        this.engines = new WeakMap();
+        this.memoryStorage = new memory_1.MemoryRateLimitStorage();
+        this.queues = new Map();
+        this.hasLoggedMissingStorage = false;
+        this.preload.add('ratelimit.js');
+    }
+    /**
+     * Initialize runtime storage and defaults for this plugin instance.
+     *
+     * @param ctx - CommandKit runtime for the active application.
+     * @returns Resolves when runtime storage has been initialized.
+     * @throws Error when the plugin has not been configured.
+     */
+    async activate(ctx) {
+        if (!(0, configure_1.isRateLimitConfigured)()) {
+            throw new Error('RateLimit is not configured. Call configureRatelimit() during startup (for example in src/ratelimit.ts).');
+        }
+        const runtimeStorage = this.resolveDefaultStorage();
+        if (!runtimeStorage) {
+            this.logMissingStorage();
+            (0, runtime_1.setRateLimitRuntime)(null);
+            return;
+        }
+        if (!(0, runtime_1.getRateLimitStorage)()) {
+            (0, runtime_1.setRateLimitStorage)(runtimeStorage);
+        }
+        (0, runtime_1.setRateLimitRuntime)({
+            storage: runtimeStorage,
+            keyPrefix: this.options.keyPrefix,
+            defaultLimiter: this.options.defaultLimiter ?? config_1.DEFAULT_LIMITER,
+            limiters: this.options.limiters,
+            hooks: this.options.hooks,
+        });
+    }
+    /**
+     * Dispose queues and clear shared runtime state.
+     *
+     * @returns Resolves after queues are aborted and runtime state is cleared.
+     */
+    async deactivate() {
+        for (const queue of this.queues.values()) {
+            queue.abort();
+        }
+        this.queues.clear();
+        (0, runtime_1.setRateLimitRuntime)(null);
+    }
+    /**
+     * Evaluate rate limits and optionally queue execution to avoid dropping commands.
+     *
+     * @param ctx - CommandKit runtime for the active application.
+     * @param env - Command execution environment.
+     * @param source - Interaction or message triggering the command.
+     * @param prepared - Prepared command execution data.
+     * @param execute - Callback that executes the command handler.
+     * @returns True when execution is deferred or handled, otherwise false to continue.
+     */
+    async executeCommand(ctx, env, source, prepared, execute) {
+        const metadata = prepared.command.metadata;
+        const rateLimitSetting = metadata?.ratelimit;
+        if (rateLimitSetting == null || rateLimitSetting === false) {
+            return false;
+        }
+        if (!env.context) {
+            return false;
+        }
+        if (await this.shouldBypass(source)) {
+            return false;
+        }
+        const commandConfig = typeof rateLimitSetting === 'object' ? rateLimitSetting : {};
+        const { limiter: limiterName, ...commandOverrides } = commandConfig;
+        const namedLimiter = limiterName
+            ? this.options.limiters?.[limiterName]
+            : undefined;
+        const mergedLimiter = (0, config_1.mergeLimiterConfigs)(config_1.DEFAULT_LIMITER, this.options.defaultLimiter, namedLimiter, commandOverrides);
+        const roleLimits = mergeRoleLimits(this.options.roleLimits, this.options.defaultLimiter?.roleLimits, namedLimiter?.roleLimits, commandOverrides.roleLimits);
+        const roleStrategy = commandOverrides.roleLimitStrategy ??
+            namedLimiter?.roleLimitStrategy ??
+            this.options.defaultLimiter?.roleLimitStrategy ??
+            this.options.roleLimitStrategy;
+        const roleOverride = resolveRoleLimit(roleLimits, roleStrategy, source);
+        const effectiveLimiter = roleOverride
+            ? (0, config_1.mergeLimiterConfigs)(mergedLimiter, roleOverride)
+            : mergedLimiter;
+        const queueConfig = resolveQueueOptions(this.options.queue, this.options.defaultLimiter?.queue, namedLimiter?.queue, commandOverrides.queue, roleOverride?.queue);
+        const scopes = normalizeScopes(effectiveLimiter.scope);
+        const keyResolver = effectiveLimiter.keyResolver ?? this.options.keyResolver;
+        const keyPrefix = effectiveLimiter.keyPrefix ?? this.options.keyPrefix;
+        const storage = this.resolveStorage(effectiveLimiter.storage) ??
+            this.resolveDefaultStorage();
+        if (!storage) {
+            this.logMissingStorage();
+            env.store.set(constants_1.RATELIMIT_STORE_KEY, createEmptyStoreValue());
+            return false;
+        }
+        const engine = this.getEngine(storage);
+        const resolvedKeys = (0, keys_1.resolveScopeKeys)({
+            ctx: env.context,
+            source,
+            command: prepared.command,
+            scopes,
+            keyPrefix,
+            keyResolver,
+        });
+        if (!resolvedKeys.length) {
+            env.store.set(constants_1.RATELIMIT_STORE_KEY, createEmptyStoreValue());
+            return false;
+        }
+        const results = [];
+        let violationCount;
+        for (const resolved of resolvedKeys) {
+            const resolvedConfigs = (0, config_1.resolveLimiterConfigs)(effectiveLimiter, resolved.scope);
+            for (const resolvedConfig of resolvedConfigs) {
+                const resolvedKey = withWindowSuffix(resolved.key, resolvedConfig.windowId);
+                let output;
+                try {
+                    output = await engine.consume(resolvedKey, resolvedConfig);
+                }
+                catch (error) {
+                    if (this.options.hooks?.onStorageError) {
+                        await this.options.hooks.onStorageError(error, false);
+                    }
+                    commandkit_1.Logger.error `[ratelimit] Storage error during consume: ${error}`;
+                    env.store.set(constants_1.RATELIMIT_STORE_KEY, createEmptyStoreValue());
+                    return false;
+                }
+                const { result, violationCount: count } = output;
+                results.push(result);
+                if (typeof count === 'number') {
+                    violationCount =
+                        violationCount == null ? count : Math.max(violationCount, count);
+                }
+                if (result.limited) {
+                    (0, commandkit_1.defer)(() => ctx.commandkit.analytics.track({
+                        name: ANALYTICS_EVENTS.HIT,
+                        id: prepared.command.command.name,
+                        data: {
+                            key: result.key,
+                            scope: result.scope,
+                            algorithm: result.algorithm,
+                            resetAt: result.resetAt,
+                            remaining: result.remaining,
+                        },
+                    }));
+                    if (violationCount != null) {
+                        (0, commandkit_1.defer)(() => ctx.commandkit.analytics.track({
+                            name: ANALYTICS_EVENTS.VIOLATION,
+                            id: prepared.command.command.name,
+                            data: {
+                                key: result.key,
+                                count: violationCount,
+                            },
+                        }));
+                    }
+                }
+                else {
+                    (0, commandkit_1.defer)(() => ctx.commandkit.analytics.track({
+                        name: ANALYTICS_EVENTS.ALLOWED,
+                        id: prepared.command.command.name,
+                        data: {
+                            key: result.key,
+                            scope: result.scope,
+                            algorithm: result.algorithm,
+                            remaining: result.remaining,
+                        },
+                    }));
+                }
+            }
+        }
+        /**
+         * Aggregate across all scopes/windows so callers see a single response.
+         */
+        const aggregate = aggregateResults(results);
+        env.store.set(constants_1.RATELIMIT_STORE_KEY, aggregate);
+        if (aggregate.limited) {
+            const firstLimited = results.find((r) => r.limited) ?? results[0];
+            if (!firstLimited) {
+                return false;
+            }
+            if (queueConfig.enabled &&
+                (await this.enqueueExecution({
+                    queueKey: selectQueueKey(results),
+                    queue: queueConfig,
+                    initialDelayMs: aggregate.retryAfter,
+                    source,
+                    execute,
+                    engine,
+                    resolvedKeys,
+                    limiter: effectiveLimiter,
+                }))) {
+                commandkit_1.Logger.info(`[ratelimit] Queued command /${prepared.command.command.name} for retry in ${Math.ceil(aggregate.retryAfter / 1000)}s`);
+                ctx.capture();
+                if (this.options.hooks?.onRateLimited) {
+                    await this.options.hooks.onRateLimited({
+                        key: firstLimited.key,
+                        result: firstLimited,
+                        source,
+                    });
+                }
+                if (violationCount != null && this.options.hooks?.onViolation) {
+                    await this.options.hooks.onViolation(firstLimited.key, violationCount);
+                }
+                this.emitRateLimited(ctx, {
+                    key: firstLimited.key,
+                    result: firstLimited,
+                    source,
+                    aggregate,
+                    commandName: prepared.command.command.name,
+                    queued: true,
+                });
+                return false;
+            }
+            commandkit_1.Logger.warn(`[ratelimit] User hit rate limit on /${prepared.command.command.name} - retry in ${Math.ceil(aggregate.retryAfter / 1000)}s`);
+            await this.respondRateLimited(env, source, aggregate);
+            if (this.options.hooks?.onRateLimited) {
+                await this.options.hooks.onRateLimited({
+                    key: firstLimited.key,
+                    result: firstLimited,
+                    source,
+                });
+            }
+            if (violationCount != null && this.options.hooks?.onViolation) {
+                await this.options.hooks.onViolation(firstLimited.key, violationCount);
+            }
+            ctx.capture();
+            this.emitRateLimited(ctx, {
+                key: firstLimited.key,
+                result: firstLimited,
+                source,
+                aggregate,
+                commandName: prepared.command.command.name,
+                queued: false,
+            });
+        }
+        else if (this.options.hooks?.onAllowed) {
+            const first = results[0];
+            if (first) {
+                await this.options.hooks.onAllowed({
+                    key: first.key,
+                    result: first,
+                    source,
+                });
+            }
+        }
+        return false;
+    }
+    /**
+     * Clear matching keys when a command is hot-reloaded to avoid stale state.
+     *
+     * @param ctx - CommandKit runtime for the active application.
+     * @param event - HMR event describing the changed file.
+     * @returns Resolves after matching keys are cleared and the event is handled.
+     */
+    async performHMR(ctx, event) {
+        if (!event.path)
+            return;
+        const normalized = normalizePath(event.path);
+        const commands = ctx.commandkit.commandHandler.getCommandsArray();
+        const matched = commands.filter((cmd) => cmd.command.path ? normalizePath(cmd.command.path) === normalized : false);
+        if (!matched.length)
+            return;
+        const storage = this.resolveDefaultStorage();
+        if (!storage) {
+            this.logMissingStorage();
+            return;
+        }
+        for (const cmd of matched) {
+            await resetByCommand(storage, this.options.keyPrefix, cmd.command.name);
+        }
+        event.accept();
+        event.preventDefault();
+    }
+    /**
+     * Resolve a cached engine instance for a storage backend.
+     *
+     * @param storage - Storage backend to associate with the engine.
+     * @returns Cached engine instance for the storage.
+     */
+    getEngine(storage) {
+        const existing = this.engines.get(storage);
+        if (existing)
+            return existing;
+        const engine = new RateLimitEngine_1.RateLimitEngine(storage);
+        this.engines.set(storage, engine);
+        return engine;
+    }
+    /**
+     * Normalize a storage config into a storage driver instance.
+     *
+     * @param config - Storage config or driver.
+     * @returns Storage driver instance or null when not configured.
+     */
+    resolveStorage(config) {
+        if (!config)
+            return null;
+        if ('driver' in config)
+            return config.driver;
+        return config;
+    }
+    /**
+     * Resolve the default storage, falling back to memory when enabled.
+     *
+     * @returns Resolved storage instance or null when disabled.
+     */
+    resolveDefaultStorage() {
+        const resolved = this.resolveStorage(this.options.storage) ?? (0, runtime_1.getRateLimitStorage)();
+        if (resolved)
+            return resolved;
+        if (this.options.initializeDefaultStorage === false ||
+            this.options.initializeDefaultDriver === false) {
+            return null;
+        }
+        return this.memoryStorage;
+    }
+    /**
+     * Log a one-time error when storage is missing.
+     *
+     * @returns Nothing; logs at most once per process.
+     */
+    logMissingStorage() {
+        if (this.hasLoggedMissingStorage)
+            return;
+        this.hasLoggedMissingStorage = true;
+        commandkit_1.Logger.error('[ratelimit] No storage configured. Set storage via configureRatelimit({ storage }), setRateLimitStorage(), or enable initializeDefaultStorage.');
+    }
+    /**
+     * Emit a ratelimited event through CommandKit's event bus.
+     *
+     * @param ctx - CommandKit runtime for the active application.
+     * @param payload - Rate-limit event payload to emit.
+     * @returns Nothing; emits the event when available.
+     */
+    emitRateLimited(ctx, payload) {
+        ctx.commandkit.events?.to('ratelimits').emit('ratelimited', payload);
+    }
+    /**
+     * Determine whether a source should bypass rate limits.
+     *
+     * @param source - Interaction or message to evaluate.
+     * @returns True when the source should bypass rate limiting.
+     */
+    async shouldBypass(source) {
+        const bypass = this.options.bypass;
+        if (bypass) {
+            /**
+             * Check permanent allowlists first to avoid storage lookups.
+             */
+            const userId = source instanceof discord_js_1.Message ? source.author.id : source.user?.id;
+            if (userId && bypass.userIds?.includes(userId))
+                return true;
+            const guildId = source.guildId ?? null;
+            if (guildId && bypass.guildIds?.includes(guildId))
+                return true;
+            const roleIds = (0, keys_1.getRoleIds)(source);
+            if (roleIds.length && bypass.roleIds?.length) {
+                if (roleIds.some((roleId) => bypass.roleIds.includes(roleId)))
+                    return true;
+            }
+        }
+        /**
+         * Check temporary exemptions stored in the rate limit storage next.
+         */
+        if (await this.hasTemporaryBypass(source)) {
+            return true;
+        }
+        /**
+         * Run custom predicate last so it can override previous checks.
+         */
+        if (bypass?.check) {
+            return Boolean(await bypass.check(source));
+        }
+        return false;
+    }
+    /**
+     * Check for temporary exemptions in storage for the source.
+     *
+     * @param source - Interaction or message to evaluate.
+     * @returns True when a temporary exemption is found.
+     */
+    async hasTemporaryBypass(source) {
+        const storage = this.resolveDefaultStorage();
+        if (!storage)
+            return false;
+        const keys = (0, keys_1.resolveExemptionKeys)(source, this.options.keyPrefix);
+        if (!keys.length)
+            return false;
+        try {
+            for (const key of keys) {
+                if (await storage.get(key))
+                    return true;
+            }
+        }
+        catch (error) {
+            if (this.options.hooks?.onStorageError) {
+                await this.options.hooks.onStorageError(error, false);
+            }
+            commandkit_1.Logger.error `[ratelimit] Storage error during exemption check: ${error}`;
+        }
+        return false;
+    }
+    /**
+     * Send the default rate-limited response when no custom handler is set.
+     *
+     * @param env - Command execution environment.
+     * @param source - Interaction or message that was limited.
+     * @param info - Aggregated rate-limit info for the response.
+     * @returns Resolves after the response is sent.
+     */
+    async respondRateLimited(env, source, info) {
+        const ctx = env.context;
+        if (this.options.onRateLimited && ctx) {
+            await this.options.onRateLimited(ctx, info);
+            return;
+        }
+        const retrySeconds = Math.ceil(info.retryAfter / 1000);
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle(':hourglass_flowing_sand: You are on cooldown')
+            .setDescription(`Try again <t:${Math.floor(info.resetAt / 1000)}:R> (in ${retrySeconds}s).`)
+            .setColor('Red');
+        if (source instanceof discord_js_1.Message) {
+            if (source.channel?.isSendable()) {
+                try {
+                    await source.reply({ embeds: [embed] });
+                }
+                catch (error) {
+                    commandkit_1.Logger.error `[ratelimit] Failed to reply with rate limit embed: ${error}`;
+                }
+            }
+            return;
+        }
+        if (!source.isRepliable())
+            return;
+        if (source.replied || source.deferred) {
+            try {
+                await source.followUp({
+                    embeds: [embed],
+                    flags: discord_js_1.MessageFlags.Ephemeral,
+                });
+            }
+            catch (error) {
+                commandkit_1.Logger.error `[ratelimit] Failed to follow up with rate limit embed: ${error}`;
+            }
+            return;
+        }
+        try {
+            await source.reply({
+                embeds: [embed],
+                flags: discord_js_1.MessageFlags.Ephemeral,
+            });
+        }
+        catch (error) {
+            commandkit_1.Logger.error `[ratelimit] Failed to reply with rate limit embed: ${error}`;
+        }
+    }
+    /**
+     * Enqueue a command execution for later retry under queue rules.
+     *
+     * @param params - Queue execution parameters.
+     * @returns True when the execution was queued.
+     */
+    async enqueueExecution(params) {
+        if (!params.queue.enabled)
+            return false;
+        const queue = this.getQueue(params.queueKey, params.queue);
+        const size = queue.getPending() + queue.getRunning();
+        if (size >= params.queue.maxSize) {
+            /**
+             * Queue full: fall back to immediate rate-limit handling to avoid unbounded growth.
+             */
+            return false;
+        }
+        await this.deferInteractionIfNeeded(params.source, params.queue);
+        const queuedAt = Date.now();
+        const timeoutAt = queuedAt + params.queue.timeoutMs;
+        const initialDelay = Math.max(0, params.initialDelayMs);
+        void queue
+            .add(async () => {
+            let delayMs = initialDelay;
+            while (true) {
+                if (delayMs > 0) {
+                    await sleep(delayMs);
+                }
+                if (Date.now() > timeoutAt) {
+                    commandkit_1.Logger.warn(`[ratelimit] Queue timeout exceeded for key ${params.queueKey}`);
+                    return;
+                }
+                const aggregate = await this.consumeForQueue(params.engine, params.limiter, params.resolvedKeys).catch(async (error) => {
+                    if (this.options.hooks?.onStorageError) {
+                        await this.options.hooks.onStorageError(error, false);
+                    }
+                    commandkit_1.Logger.error `[ratelimit] Storage error during queued consume: ${error}`;
+                    return null;
+                });
+                if (!aggregate) {
+                    return;
+                }
+                if (!aggregate.limited) {
+                    await params.execute();
+                    return;
+                }
+                delayMs = Math.max(aggregate.retryAfter, 250);
+            }
+        })
+            .catch((error) => {
+            commandkit_1.Logger.error `[ratelimit] Queue task failed: ${error}`;
+        });
+        return true;
+    }
+    /**
+     * Get or create an async queue for the given key.
+     *
+     * @param key - Queue identifier.
+     * @param options - Normalized queue settings.
+     * @returns Async queue instance.
+     */
+    getQueue(key, options) {
+        const existing = this.queues.get(key);
+        if (existing)
+            return existing;
+        const queue = (0, async_queue_1.createAsyncQueue)({ concurrency: options.concurrency });
+        this.queues.set(key, queue);
+        return queue;
+    }
+    /**
+     * Consume limits for queued execution to decide whether to run now.
+     *
+     * @param engine - Rate limit engine.
+     * @param limiter - Resolved limiter configuration.
+     * @param resolvedKeys - Scope keys to consume.
+     * @returns Aggregated rate-limit info for the queue check.
+     */
+    async consumeForQueue(engine, limiter, resolvedKeys) {
+        const results = [];
+        for (const resolved of resolvedKeys) {
+            const resolvedConfigs = (0, config_1.resolveLimiterConfigs)(limiter, resolved.scope);
+            for (const resolvedConfig of resolvedConfigs) {
+                const resolvedKey = withWindowSuffix(resolved.key, resolvedConfig.windowId);
+                const output = await engine.consume(resolvedKey, resolvedConfig);
+                results.push(output.result);
+            }
+        }
+        return aggregateResults(results);
+    }
+    /**
+     * Defer interaction replies when queueing and the source is repliable.
+     *
+     * @param source - Interaction or message that may be deferred.
+     * @param queue - Normalized queue settings.
+     * @returns Resolves after attempting to defer the interaction.
+     */
+    async deferInteractionIfNeeded(source, queue) {
+        if (!queue.deferInteraction)
+            return;
+        if (source instanceof discord_js_1.Message)
+            return;
+        if (!source.isRepliable())
+            return;
+        if (source.deferred || source.replied)
+            return;
+        try {
+            await source.deferReply({
+                flags: queue.ephemeral ? discord_js_1.MessageFlags.Ephemeral : undefined,
+            });
+        }
+        catch (error) {
+            commandkit_1.Logger.debug(`[ratelimit] Failed to defer interaction for queued command: ${error}`);
+        }
+    }
+}
+exports.RateLimitPlugin = RateLimitPlugin;
+/**
+ * Normalize scope input into a de-duplicated scope array.
+ *
+ * @param scope - Scope config value.
+ * @returns Array of scopes to enforce.
+ */
+function normalizeScopes(scope) {
+    if (!scope)
+        return ['user'];
+    if (Array.isArray(scope))
+        return Array.from(new Set(scope));
+    return [scope];
+}
+/**
+ * Aggregate multiple rate-limit results into a single summary object.
+ *
+ * @param results - Individual limiter/window results.
+ * @returns Aggregated rate-limit store value.
+ */
+function aggregateResults(results) {
+    if (!results.length) {
+        return createEmptyStoreValue();
+    }
+    const limitedResults = results.filter((r) => r.limited);
+    const limited = limitedResults.length > 0;
+    const remaining = Math.min(...results.map((r) => r.remaining));
+    const resetAt = Math.max(...results.map((r) => r.resetAt));
+    const retryAfter = limited
+        ? Math.max(...limitedResults.map((r) => r.retryAfter))
+        : 0;
+    return {
+        limited,
+        remaining,
+        resetAt,
+        retryAfter,
+        results,
+    };
+}
+/**
+ * Append a window suffix to a key when a window id is present.
+ *
+ * @param key - Base storage key.
+ * @param windowId - Optional window identifier.
+ * @returns Key with window suffix when provided.
+ */
+function withWindowSuffix(key, windowId) {
+    if (!windowId)
+        return key;
+    return `${key}:w:${windowId}`;
+}
+/**
+ * Create an empty aggregate result for cases with no limiter results.
+ *
+ * @returns Empty rate-limit store value.
+ */
+function createEmptyStoreValue() {
+    return {
+        limited: false,
+        remaining: 0,
+        resetAt: 0,
+        retryAfter: 0,
+        results: [],
+    };
+}
+/**
+ * Merge multiple role limit maps, with later maps overriding earlier ones.
+ *
+ * @param limits - Role limit maps ordered from lowest to highest priority.
+ * @returns Merged role limits or undefined when empty.
+ */
+function mergeRoleLimits(...limits) {
+    const merged = {};
+    for (const limit of limits) {
+        if (!limit)
+            continue;
+        Object.assign(merged, limit);
+    }
+    return Object.keys(merged).length ? merged : undefined;
+}
+/**
+ * Resolve a role-specific limiter for a source using a strategy.
+ *
+ * @param limits - Role limit map keyed by role id.
+ * @param strategy - Role limit strategy to apply.
+ * @param source - Interaction or message to resolve roles from.
+ * @returns Resolved role limiter or null when none match.
+ */
+function resolveRoleLimit(limits, strategy, source) {
+    if (!limits)
+        return null;
+    const roleIds = (0, keys_1.getRoleIds)(source);
+    if (!roleIds.length)
+        return null;
+    const entries = Object.entries(limits).filter(([roleId]) => roleIds.includes(roleId));
+    if (!entries.length)
+        return null;
+    const resolvedStrategy = strategy ?? 'highest';
+    if (resolvedStrategy === 'first') {
+        return entries[0]?.[1] ?? null;
+    }
+    const scored = entries.map(([, limiter]) => ({
+        limiter,
+        score: computeLimiterScore(limiter),
+    }));
+    scored.sort((a, b) => {
+        if (resolvedStrategy === 'lowest') {
+            return a.score - b.score;
+        }
+        return b.score - a.score;
+    });
+    return scored[0]?.limiter ?? null;
+}
+/**
+ * Compute a comparable score for a limiter for role-strategy sorting.
+ *
+ * @param limiter - Limiter configuration to score.
+ * @returns Minimum request rate across windows.
+ */
+function computeLimiterScore(limiter) {
+    const resolvedConfigs = (0, config_1.resolveLimiterConfigs)(limiter, 'user');
+    if (!resolvedConfigs.length)
+        return 0;
+    const scores = resolvedConfigs.map((resolved) => resolved.maxRequests / resolved.intervalMs);
+    return Math.min(...scores);
+}
+/**
+ * Merge and normalize queue options across config layers.
+ *
+ * @param options - Queue option layers ordered from lowest to highest priority.
+ * @returns Normalized queue options.
+ */
+function resolveQueueOptions(...options) {
+    const merged = options.reduce((acc, opt) => ({ ...acc, ...(opt ?? {}) }), {});
+    const hasConfig = options.some((opt) => opt != null);
+    const enabled = merged.enabled ?? hasConfig;
+    return {
+        enabled,
+        maxSize: (0, time_1.clampAtLeast)(merged.maxSize ?? 3, 1),
+        timeoutMs: (0, time_1.clampAtLeast)((0, time_1.resolveDuration)(merged.timeout, 30000), 1),
+        deferInteraction: merged.deferInteraction !== false,
+        ephemeral: merged.ephemeral !== false,
+        concurrency: (0, time_1.clampAtLeast)(merged.concurrency ?? 1, 1),
+    };
+}
+/**
+ * Select the queue key from the result with the longest retry delay.
+ *
+ * @param results - Rate limit results for the command.
+ * @returns Queue key to use for serialization.
+ */
+function selectQueueKey(results) {
+    let target;
+    for (const result of results) {
+        if (!result.limited)
+            continue;
+        if (!target || result.retryAfter > target.retryAfter) {
+            target = result;
+        }
+    }
+    return (target ?? results[0])?.key ?? 'ratelimit:queue';
+}
+/**
+ * Delay execution for a given duration.
+ *
+ * @param ms - Delay duration in milliseconds.
+ * @returns Promise that resolves after the delay.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Reset all rate-limit keys for a specific command name.
+ *
+ * @param storage - Storage backend to delete from.
+ * @param keyPrefix - Optional prefix to prepend to the key.
+ * @param commandName - Command name to reset.
+ * @returns Resolves after matching keys are deleted.
+ */
+async function resetByCommand(storage, keyPrefix, commandName) {
+    if (!storage.deleteByPattern)
+        return;
+    const prefix = keyPrefix ?? '';
+    const pattern = `${prefix}*:${commandName}`;
+    await storage.deleteByPattern(pattern);
+    await storage.deleteByPattern(`violation:${pattern}`);
+    await storage.deleteByPattern(`${pattern}:w:*`);
+    await storage.deleteByPattern(`violation:${pattern}:w:*`);
+}
+/**
+ * Normalize path separators to forward slashes for comparisons.
+ *
+ * @param path - Path to normalize.
+ * @returns Normalized path string.
+ */
+function normalizePath(path) {
+    return path.replace(/\\/g, '/');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":";;;AAAA,2CAA0D;AAO1D,wDAA2E;AAC3E,2CAAiE;AAEjE,8DAA2D;AAa3D,2CAIwB;AACxB,uCAIsB;AAEtB,2CAAkD;AAClD,6CAA0D;AAC1D,uCAImB;AACnB,2CAAoD;AACpD,uCAA6D;AAE7D,MAAM,gBAAgB,GAAG;IACvB,GAAG,EAAE,eAAe;IACpB,OAAO,EAAE,mBAAmB;IAC5B,KAAK,EAAE,iBAAiB;IACxB,SAAS,EAAE,qBAAqB;CACxB,CAAC;AAWX;;;;GAIG;AACH,MAAa,eAAgB,SAAQ,0BAAqC;IAOxE,YAAmB,OAA+B;QAChD,KAAK,CAAC,OAAO,CAAC,CAAC;QAPD,SAAI,GAAG,iBAAiB,CAAC;QACxB,YAAO,GAAG,IAAI,OAAO,EAAqC,CAAC;QAC3D,kBAAa,GAAG,IAAI,+BAAsB,EAAE,CAAC;QAC7C,WAAM,GAAG,IAAI,GAAG,EAAsB,CAAC;QAChD,4BAAuB,GAAG,KAAK,CAAC;QAItC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,QAAQ,CAAC,GAA4B;QAChD,IAAI,CAAC,IAAA,iCAAqB,GAAE,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G,CAAC;QACJ,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAEpD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAA,6BAAmB,EAAC,IAAI,CAAC,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,CAAC,IAAA,6BAAmB,GAAE,EAAE,CAAC;YAC3B,IAAA,6BAAmB,EAAC,cAAc,CAAC,CAAC;QACtC,CAAC;QAED,IAAA,6BAAmB,EAAC;YAClB,OAAO,EAAE,cAAc;YACvB,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,cAAc,IAAI,wBAAe;YAC9D,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;YAC/B,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK;SAC1B,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,UAAU;QACrB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC;YACzC,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAA,6BAAmB,EAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,cAAc,CACzB,GAA4B,EAC5B,GAA0B,EAC1B,MAA6B,EAC7B,QAAqC,EACrC,OAA2B;QAE3B,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,QAEjC,CAAC;QAEF,MAAM,gBAAgB,GAAG,QAAQ,EAAE,SAAS,CAAC;QAC7C,IAAI,gBAAgB,IAAI,IAAI,IAAI,gBAAgB,KAAK,KAAK,EAAE,CAAC;YAC3D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;YACpC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,aAAa,GACjB,OAAO,gBAAgB,KAAK,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;QAE/D,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,gBAAgB,EAAE,GAAG,aAAa,CAAC;QACpE,MAAM,YAAY,GAAG,WAAW;YAC9B,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,WAAW,CAAC;YACtC,CAAC,CAAC,SAAS,CAAC;QAEd,MAAM,aAAa,GAAG,IAAA,4BAAmB,EACvC,wBAAe,EACf,IAAI,CAAC,OAAO,CAAC,cAAc,EAC3B,YAAY,EACZ,gBAAgB,CACjB,CAAC;QAEF,MAAM,UAAU,GAAG,eAAe,CAChC,IAAI,CAAC,OAAO,CAAC,UAAU,EACvB,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,UAAU,EACvC,YAAY,EAAE,UAAU,EACxB,gBAAgB,CAAC,UAAU,CAC5B,CAAC;QACF,MAAM,YAAY,GAChB,gBAAgB,CAAC,iBAAiB;YAClC,YAAY,EAAE,iBAAiB;YAC/B,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,iBAAiB;YAC9C,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC;QACjC,MAAM,YAAY,GAAG,gBAAgB,CAAC,UAAU,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;QAExE,MAAM,gBAAgB,GAAG,YAAY;YACnC,CAAC,CAAC,IAAA,4BAAmB,EAAC,aAAa,EAAE,YAAY,CAAC;YAClD,CAAC,CAAC,aAAa,CAAC;QAElB,MAAM,WAAW,GAAG,mBAAmB,CACrC,IAAI,CAAC,OAAO,CAAC,KAAK,EAClB,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,KAAK,EAClC,YAAY,EAAE,KAAK,EACnB,gBAAgB,CAAC,KAAK,EACtB,YAAY,EAAE,KAAK,CACpB,CAAC;QAEF,MAAM,MAAM,GAAG,eAAe,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACvD,MAAM,WAAW,GACf,gBAAgB,CAAC,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;QAC3D,MAAM,SAAS,GAAG,gBAAgB,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;QACvE,MAAM,OAAO,GACX,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAC7C,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE/B,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,+BAAmB,EAAE,qBAAqB,EAAE,CAAC,CAAC;YAC5D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAEvC,MAAM,YAAY,GAAG,IAAA,uBAAgB,EAAC;YACpC,GAAG,EAAE,GAAG,CAAC,OAAO;YAChB,MAAM;YACN,OAAO,EAAE,QAAQ,CAAC,OAAO;YACzB,MAAM;YACN,SAAS;YACT,WAAW;SACZ,CAAC,CAAC;QAEH,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;YACzB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,+BAAmB,EAAE,qBAAqB,EAAE,CAAC,CAAC;YAC5D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,OAAO,GAAsB,EAAE,CAAC;QACtC,IAAI,cAAkC,CAAC;QAEvC,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE,CAAC;YACpC,MAAM,eAAe,GAAG,IAAA,8BAAqB,EAC3C,gBAAgB,EAChB,QAAQ,CAAC,KAAK,CACf,CAAC;YAEF,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE,CAAC;gBAC7C,MAAM,WAAW,GAAG,gBAAgB,CAClC,QAAQ,CAAC,GAAG,EACZ,cAAc,CAAC,QAAQ,CACxB,CAAC;gBAEF,IAAI,MAAuD,CAAC;gBAC5D,IAAI,CAAC;oBACH,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;gBAC7D,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC;wBACvC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBACxD,CAAC;oBACD,mBAAM,CAAC,KAAK,CAAA,6CAA6C,KAAK,EAAE,CAAC;oBACjE,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,+BAAmB,EAAE,qBAAqB,EAAE,CAAC,CAAC;oBAC5D,OAAO,KAAK,CAAC;gBACf,CAAC;gBAED,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;gBACjD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACrB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC9B,cAAc;wBACZ,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;gBACrE,CAAC;gBAED,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,IAAA,kBAAK,EAAC,GAAG,EAAE,CACT,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC;wBAC7B,IAAI,EAAE,gBAAgB,CAAC,GAAG;wBAC1B,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI;wBACjC,IAAI,EAAE;4BACJ,GAAG,EAAE,MAAM,CAAC,GAAG;4BACf,KAAK,EAAE,MAAM,CAAC,KAAK;4BACnB,SAAS,EAAE,MAAM,CAAC,SAAS;4BAC3B,OAAO,EAAE,MAAM,CAAC,OAAO;4BACvB,SAAS,EAAE,MAAM,CAAC,SAAS;yBAC5B;qBACF,CAAC,CACH,CAAC;oBAEF,IAAI,cAAc,IAAI,IAAI,EAAE,CAAC;wBAC3B,IAAA,kBAAK,EAAC,GAAG,EAAE,CACT,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC;4BAC7B,IAAI,EAAE,gBAAgB,CAAC,SAAS;4BAChC,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI;4BACjC,IAAI,EAAE;gCACJ,GAAG,EAAE,MAAM,CAAC,GAAG;gCACf,KAAK,EAAE,cAAc;6BACtB;yBACF,CAAC,CACH,CAAC;oBACJ,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAA,kBAAK,EAAC,GAAG,EAAE,CACT,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC;wBAC7B,IAAI,EAAE,gBAAgB,CAAC,OAAO;wBAC9B,EAAE,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI;wBACjC,IAAI,EAAE;4BACJ,GAAG,EAAE,MAAM,CAAC,GAAG;4BACf,KAAK,EAAE,MAAM,CAAC,KAAK;4BACnB,SAAS,EAAE,MAAM,CAAC,SAAS;4BAC3B,SAAS,EAAE,MAAM,CAAC,SAAS;yBAC5B;qBACF,CAAC,CACH,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED;;WAEG;QACH,MAAM,SAAS,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC5C,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,+BAAmB,EAAE,SAAS,CAAC,CAAC;QAE9C,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACtB,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;YAClE,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,OAAO,KAAK,CAAC;YACf,CAAC;YAED,IACE,WAAW,CAAC,OAAO;gBACnB,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC;oBAC3B,QAAQ,EAAE,cAAc,CAAC,OAAO,CAAC;oBACjC,KAAK,EAAE,WAAW;oBAClB,cAAc,EAAE,SAAS,CAAC,UAAU;oBACpC,MAAM;oBACN,OAAO;oBACP,MAAM;oBACN,YAAY;oBACZ,OAAO,EAAE,gBAAgB;iBAC1B,CAAC,CAAC,EACH,CAAC;gBACD,mBAAM,CAAC,IAAI,CACT,+BAA+B,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,iBAAiB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CACvH,CAAC;gBACF,GAAG,CAAC,OAAO,EAAE,CAAC;gBACd,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC;oBACtC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC;wBACrC,GAAG,EAAE,YAAY,CAAC,GAAG;wBACrB,MAAM,EAAE,YAAY;wBACpB,MAAM;qBACP,CAAC,CAAC;gBACL,CAAC;gBAED,IAAI,cAAc,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC;oBAC9D,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAClC,YAAY,CAAC,GAAG,EAChB,cAAc,CACf,CAAC;gBACJ,CAAC;gBAED,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE;oBACxB,GAAG,EAAE,YAAY,CAAC,GAAG;oBACrB,MAAM,EAAE,YAAY;oBACpB,MAAM;oBACN,SAAS;oBACT,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI;oBAC1C,MAAM,EAAE,IAAI;iBACb,CAAC,CAAC;gBAEH,OAAO,KAAK,CAAC;YACf,CAAC;YAED,mBAAM,CAAC,IAAI,CACT,uCAAuC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,eAAe,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAC7H,CAAC;YAEF,MAAM,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;YAEtD,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC;gBACtC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC;oBACrC,GAAG,EAAE,YAAY,CAAC,GAAG;oBACrB,MAAM,EAAE,YAAY;oBACpB,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;YAED,IAAI,cAAc,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC;gBAC9D,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,YAAY,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;YACzE,CAAC;YAED,GAAG,CAAC,OAAO,EAAE,CAAC;YAEd,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE;gBACxB,GAAG,EAAE,YAAY,CAAC,GAAG;gBACrB,MAAM,EAAE,YAAY;gBACpB,MAAM;gBACN,SAAS;gBACT,WAAW,EAAE,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI;gBAC1C,MAAM,EAAE,KAAK;aACd,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,KAAK,EAAE,CAAC;gBACV,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC;oBACjC,GAAG,EAAE,KAAK,CAAC,GAAG;oBACd,MAAM,EAAE,KAAK;oBACb,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,UAAU,CACrB,GAA4B,EAC5B,KAAyB;QAEzB,IAAI,CAAC,KAAK,CAAC,IAAI;YAAE,OAAO;QAExB,MAAM,UAAU,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7C,MAAM,QAAQ,GAAG,GAAG,CAAC,UAAU,CAAC,cAAc,CAAC,gBAAgB,EAAE,CAAC;QAClE,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CACtC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAC1E,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO;QAE5B,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,OAAO;QACT,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,MAAM,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1E,CAAC;QAED,KAAK,CAAC,MAAM,EAAE,CAAC;QACf,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAED;;;;;OAKG;IACK,SAAS,CAAC,OAAyB;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC3C,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,iCAAe,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACK,cAAc,CACpB,MAA+B;QAE/B,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QACzB,IAAI,QAAQ,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC,MAAM,CAAC;QAC7C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACK,qBAAqB;QAC3B,MAAM,QAAQ,GACZ,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,IAAA,6BAAmB,GAAE,CAAC;QAErE,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,IACE,IAAI,CAAC,OAAO,CAAC,wBAAwB,KAAK,KAAK;YAC/C,IAAI,CAAC,OAAO,CAAC,uBAAuB,KAAK,KAAK,EAC9C,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACK,iBAAiB;QACvB,IAAI,IAAI,CAAC,uBAAuB;YAAE,OAAO;QACzC,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACpC,mBAAM,CAAC,KAAK,CACV,gJAAgJ,CACjJ,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACK,eAAe,CACrB,GAA4B,EAC5B,OAA8B;QAE9B,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IACvE,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,YAAY,CAAC,MAA6B;QACtD,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACnC,IAAI,MAAM,EAAE,CAAC;YACX;;eAEG;YACH,MAAM,MAAM,GACV,MAAM,YAAY,oBAAO,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YACjE,IAAI,MAAM,IAAI,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC;gBAAE,OAAO,IAAI,CAAC;YAE5D,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;YACvC,IAAI,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;YAE/D,MAAM,OAAO,GAAG,IAAA,iBAAU,EAAC,MAAM,CAAC,CAAC;YACnC,IAAI,OAAO,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;gBAC7C,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBAC5D,OAAO,IAAI,CAAC;YAChB,CAAC;QACH,CAAC;QAED;;WAEG;QACH,IAAI,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC;QACd,CAAC;QAED;;WAEG;QACH,IAAI,MAAM,EAAE,KAAK,EAAE,CAAC;YAClB,OAAO,OAAO,CAAC,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,kBAAkB,CAC9B,MAA6B;QAE7B,MAAM,OAAO,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC7C,IAAI,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAE3B,MAAM,IAAI,GAAG,IAAA,2BAAoB,EAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,KAAK,CAAC;QAE/B,IAAI,CAAC;YACH,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,IAAI,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;oBAAE,OAAO,IAAI,CAAC;YAC1C,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC;gBACvC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACxD,CAAC;YACD,mBAAM,CAAC,KAAK,CAAA,qDAAqD,KAAK,EAAE,CAAC;QAC3E,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,kBAAkB,CAC9B,GAA0B,EAC1B,MAA6B,EAC7B,IAAyB;QAEzB,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC;QACxB,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,IAAI,GAAG,EAAE,CAAC;YACtC,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YAC5C,OAAO;QACT,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;QACvD,MAAM,KAAK,GAAG,IAAI,yBAAY,EAAE;aAC7B,QAAQ,CAAC,8CAA8C,CAAC;aACxD,cAAc,CACb,gBAAgB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW,YAAY,KAAK,CAC5E;aACA,QAAQ,CAAC,KAAK,CAAC,CAAC;QAEnB,IAAI,MAAM,YAAY,oBAAO,EAAE,CAAC;YAC9B,IAAI,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC;gBACjC,IAAI,CAAC;oBACH,MAAM,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAC1C,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,mBAAM,CAAC,KAAK,CAAA,sDAAsD,KAAK,EAAE,CAAC;gBAC5E,CAAC;YACH,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE;YAAE,OAAO;QAElC,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YACtC,IAAI,CAAC;gBACH,MAAM,MAAM,CAAC,QAAQ,CAAC;oBACpB,MAAM,EAAE,CAAC,KAAK,CAAC;oBACf,KAAK,EAAE,yBAAY,CAAC,SAAS;iBAC9B,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,mBAAM,CAAC,KAAK,CAAA,0DAA0D,KAAK,EAAE,CAAC;YAChF,CAAC;YACD,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,KAAK,CAAC;gBACjB,MAAM,EAAE,CAAC,KAAK,CAAC;gBACf,KAAK,EAAE,yBAAY,CAAC,SAAS;aAC9B,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,mBAAM,CAAC,KAAK,CAAA,sDAAsD,KAAK,EAAE,CAAC;QAC5E,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,gBAAgB,CAAC,MAS9B;QACC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO;YAAE,OAAO,KAAK,CAAC;QAExC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3D,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,EAAE,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACrD,IAAI,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACjC;;eAEG;YACH,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAEjE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;QAExD,KAAK,KAAK;aACP,GAAG,CAAC,KAAK,IAAI,EAAE;YACd,IAAI,OAAO,GAAG,YAAY,CAAC;YAC3B,OAAO,IAAI,EAAE,CAAC;gBACZ,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;oBAChB,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC;gBACvB,CAAC;gBAED,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,EAAE,CAAC;oBAC3B,mBAAM,CAAC,IAAI,CACT,8CAA8C,MAAM,CAAC,QAAQ,EAAE,CAChE,CAAC;oBACF,OAAO;gBACT,CAAC;gBAED,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,CAC1C,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,YAAY,CACpB,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;oBACtB,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,CAAC;wBACvC,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBACxD,CAAC;oBACD,mBAAM,CAAC,KAAK,CAAA,oDAAoD,KAAK,EAAE,CAAC;oBACxE,OAAO,IAAI,CAAC;gBACd,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;oBACvB,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;oBACvB,OAAO;gBACT,CAAC;gBAED,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YAChD,CAAC;QACH,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;YACf,mBAAM,CAAC,KAAK,CAAA,kCAAkC,KAAK,EAAE,CAAC;QACxD,CAAC,CAAC,CAAC;QAEL,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACK,QAAQ,CAAC,GAAW,EAAE,OAA+B;QAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAC;QAC9B,MAAM,KAAK,GAAG,IAAA,8BAAgB,EAAC,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QACrE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC5B,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,eAAe,CAC3B,MAAuB,EACvB,OAA+B,EAC/B,YAAgC;QAEhC,MAAM,OAAO,GAAsB,EAAE,CAAC;QACtC,KAAK,MAAM,QAAQ,IAAI,YAAY,EAAE,CAAC;YACpC,MAAM,eAAe,GAAG,IAAA,8BAAqB,EAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;YACvE,KAAK,MAAM,cAAc,IAAI,eAAe,EAAE,CAAC;gBAC7C,MAAM,WAAW,GAAG,gBAAgB,CAClC,QAAQ,CAAC,GAAG,EACZ,cAAc,CAAC,QAAQ,CACxB,CAAC;gBACF,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;gBACjE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;QAED,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,wBAAwB,CACpC,MAA6B,EAC7B,KAA6B;QAE7B,IAAI,CAAC,KAAK,CAAC,gBAAgB;YAAE,OAAO;QACpC,IAAI,MAAM,YAAY,oBAAO;YAAE,OAAO;QACtC,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE;YAAE,OAAO;QAClC,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,OAAO;YAAE,OAAO;QAE9C,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,UAAU,CAAC;gBACtB,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,yBAAY,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;aAC5D,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,mBAAM,CAAC,KAAK,CACV,+DAA+D,KAAK,EAAE,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA7tBD,0CA6tBC;AAWD;;;;;GAKG;AACH,SAAS,eAAe,CACtB,KAAkD;IAElD,IAAI,CAAC,KAAK;QAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,KAAK,CAAC,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,OAA0B;IAClD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACpB,OAAO,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAED,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3D,MAAM,UAAU,GAAG,OAAO;QACxB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC,CAAC;IAEN,OAAO;QACL,OAAO;QACP,SAAS;QACT,OAAO;QACP,UAAU;QACV,OAAO;KACR,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,GAAW,EAAE,QAAiB;IACtD,IAAI,CAAC,QAAQ;QAAE,OAAO,GAAG,CAAC;IAC1B,OAAO,GAAG,GAAG,MAAM,QAAQ,EAAE,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,SAAS,qBAAqB;IAC5B,OAAO;QACL,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,CAAC;QACZ,OAAO,EAAE,CAAC;QACV,UAAU,EAAE,CAAC;QACb,OAAO,EAAE,EAAE;KACZ,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,eAAe,CACtB,GAAG,MAAiE;IAEpE,MAAM,MAAM,GAA2C,EAAE,CAAC;IAC1D,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACzD,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,gBAAgB,CACvB,MAA0D,EAC1D,QAAgD,EAChD,MAA6B;IAE7B,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IACzB,MAAM,OAAO,GAAG,IAAA,iBAAU,EAAC,MAAM,CAAC,CAAC;IACnC,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEjC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,CACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CACzB,CAAC;IACF,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEjC,MAAM,gBAAgB,GAAG,QAAQ,IAAI,SAAS,CAAC;IAC/C,IAAI,gBAAgB,KAAK,OAAO,EAAE,CAAC;QACjC,OAAO,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IACjC,CAAC;IAED,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;QAC3C,OAAO;QACP,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC;KACpC,CAAC,CAAC,CAAC;IAEJ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACnB,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YAClC,OAAO,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;QAC3B,CAAC;QACD,OAAO,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;IAC3B,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,OAA+B;IAC1D,MAAM,eAAe,GAAG,IAAA,8BAAqB,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/D,IAAI,CAAC,eAAe,CAAC,MAAM;QAAE,OAAO,CAAC,CAAC;IACtC,MAAM,MAAM,GAAG,eAAe,CAAC,GAAG,CAChC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,UAAU,CACzD,CAAC;IACF,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;AAC7B,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAC1B,GAAG,OAAiD;IAEpD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAC3B,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,EAC1C,EAAE,CACH,CAAC;IACF,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;IACrD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,SAAS,CAAC;IAE5C,OAAO;QACL,OAAO;QACP,OAAO,EAAE,IAAA,mBAAY,EAAC,MAAM,CAAC,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC;QAC7C,SAAS,EAAE,IAAA,mBAAY,EAAC,IAAA,sBAAe,EAAC,MAAM,CAAC,OAAO,EAAE,KAAM,CAAC,EAAE,CAAC,CAAC;QACnE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,KAAK,KAAK;QACnD,SAAS,EAAE,MAAM,CAAC,SAAS,KAAK,KAAK;QACrC,WAAW,EAAE,IAAA,mBAAY,EAAC,MAAM,CAAC,WAAW,IAAI,CAAC,EAAE,CAAC,CAAC;KACtD,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,cAAc,CAAC,OAA0B;IAChD,IAAI,MAAmC,CAAC;IACxC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,OAAO;YAAE,SAAS;QAC9B,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;YACrD,MAAM,GAAG,MAAM,CAAC;QAClB,CAAC;IACH,CAAC;IACD,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,iBAAiB,CAAC;AAC1D,CAAC;AAED;;;;;GAKG;AACH,SAAS,KAAK,CAAC,EAAU;IACvB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,cAAc,CAC3B,OAAyB,EACzB,SAA6B,EAC7B,WAAmB;IAEnB,IAAI,CAAC,OAAO,CAAC,eAAe;QAAE,OAAO;IACrC,MAAM,MAAM,GAAG,SAAS,IAAI,EAAE,CAAC;IAC/B,MAAM,OAAO,GAAG,GAAG,MAAM,KAAK,WAAW,EAAE,CAAC;IAC5C,MAAM,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACvC,MAAM,OAAO,CAAC,eAAe,CAAC,aAAa,OAAO,EAAE,CAAC,CAAC;IACtD,MAAM,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,MAAM,CAAC,CAAC;IAChD,MAAM,OAAO,CAAC,eAAe,CAAC,aAAa,OAAO,MAAM,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,IAAY;IACjC,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AAClC,CAAC"}