xernerx 4.4.19 → 4.5.1

package/dist/build/ContextCommandBuilder.d.ts

@@ -12,32 +12,40 @@ export default class ContextCommandBuilder {
     readonly info: string | null | undefined;
     readonly category: string | null | undefined;
     readonly cooldown: number | null | undefined;
-    readonly ignore: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
-        dm?: boolean | undefined;
-    } | undefined;
-    readonly defer: {
-        reply?: boolean | undefined;
-        ephemeral?: boolean | undefined;
-        fetchReply?: boolean | undefined;
-    } | undefined;
+    readonly ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly permissions:
+        | {
+              user?: string[] | import('../main.js').PermissionNames[] | undefined;
+              client?: string[] | import('../main.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    readonly defer:
+        | {
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetchReply?: boolean | undefined;
+          }
+        | undefined;
     readonly fileType: 'ContextCommand';
     readonly filePath: string;
     readonly client: typeof XernerxClient;
     constructor(id: string, options: ContextCommandOptions);
     exec<T>(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<void | any | T>;
 }
-//# sourceMappingURL=ContextCommandBuilder.d.ts.map
+//# sourceMappingURL=ContextCommandBuilder.d.ts.map

package/dist/build/ContextCommandBuilder.js

@@ -11,44 +11,44 @@ export default class ContextCommandBuilder {
         this.data.setDMPermission(options.permissions?.dm || null);
         options = z
             .object({
-            name: z.string(),
-            type: z.enum(['user', 'message']),
-            description: z.string().or(z.null()).default(null),
-            usage: z.string().or(z.null()).default(null),
-            info: z.string().or(z.null()).default(null),
-            category: z.string().or(z.null()).default(null),
-            cooldown: z.number().or(z.null()).default(null),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
+                name: z.string(),
+                type: z.enum(['user', 'message']),
+                description: z.string().or(z.null()).default(null),
+                usage: z.string().or(z.null()).default(null),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                cooldown: z.number().or(z.null()).default(null),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetch: z.boolean().default(false),
+                    })
+                    .default({}),
             })
-                .default({}),
-            strict: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
-            })
-                .default({}),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
-            })
-                .default({}),
-            defer: z
-                .object({
-                reply: z.boolean().default(false),
-                ephemeral: z.boolean().default(false),
-                fetch: z.boolean().default(false),
-            })
-                .default({}),
-        })
             .parse(options);
         this.name = options.name;
         this.type = options.type;
@@ -63,6 +63,6 @@ export default class ContextCommandBuilder {
         this.defer = options.defer;
         this.client = XernerxClient;
     }
-    async exec(interaction, args) { }
+    async exec(interaction, args) {}
 }
-//# sourceMappingURL=ContextCommandBuilder.js.map
+//# sourceMappingURL=ContextCommandBuilder.js.map

package/dist/build/EventBuilder.d.ts

@@ -22,4 +22,4 @@ export default class EventBuilder {
      */
     run(...args: any): Promise<void>;
 }
-//# sourceMappingURL=EventBuilder.d.ts.map
+//# sourceMappingURL=EventBuilder.d.ts.map

package/dist/build/EventBuilder.js

@@ -25,6 +25,6 @@ export default class EventBuilder {
      * @description run your custom event here.
      * TODO - update description
      */
-    async run(...args) { }
+    async run(...args) {}
 }
-//# sourceMappingURL=EventBuilder.js.map
+//# sourceMappingURL=EventBuilder.js.map

package/dist/build/InhibitorBuilder.d.ts

@@ -15,6 +15,15 @@ export default class InhibitorBuilder {
     readonly filePath: string;
     readonly client: typeof XernerxClient;
     constructor(id: string, options: InhibitorBuilderOptions);
-    check<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, args: T extends XernerxMessage ? MessageCommandArguments : T extends XernerxSlashInteraction ? SlashCommandArguments : T extends XernerxUserContextInteraction ? XernerxUserContextInteraction : XernerxMessageContextInteraction | null): Promise<void | any | T>;
+    check<T extends XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>>(
+        interaction: XernerxMessage | XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
+        args: T extends XernerxMessage
+            ? MessageCommandArguments
+            : T extends XernerxSlashInteraction
+            ? SlashCommandArguments
+            : T extends XernerxUserContextInteraction
+            ? XernerxUserContextInteraction
+            : XernerxMessageContextInteraction | null
+    ): Promise<void | any | T>;
 }
-//# sourceMappingURL=InhibitorBuilder.d.ts.map
+//# sourceMappingURL=InhibitorBuilder.d.ts.map

package/dist/build/InhibitorBuilder.js

@@ -16,6 +16,6 @@ export default class InhibitorBuilder {
         this.type = options.type;
         this.client = XernerxClient;
     }
-    async check(interaction, args) { }
+    async check(interaction, args) {}
 }
-//# sourceMappingURL=InhibitorBuilder.js.map
+//# sourceMappingURL=InhibitorBuilder.js.map

package/dist/build/MessageCommandBuilder.d.ts

@@ -11,27 +11,33 @@ export default class MessageCommandBuilder {
     readonly usage: string | null | undefined;
     readonly info: string | null | undefined;
     readonly separator: string | undefined;
-    readonly args: import("../types/interfaces.js").MessageCommandArgumentOptions[] | undefined;
-    readonly flags: import("../types/interfaces.js").MessageCommandFlagOptions[] | undefined;
+    readonly args: import('../types/interfaces.js').MessageCommandArgumentOptions[] | undefined;
+    readonly flags: import('../types/interfaces.js').MessageCommandFlagOptions[] | undefined;
     readonly category: string | null | undefined;
     readonly cooldown: number | null | undefined;
-    readonly ignore: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly permissions: {
-        user?: string[] | import("../main.js").PermissionNames[] | undefined;
-        client?: string[] | import("../main.js").PermissionNames[] | undefined;
-        dm?: boolean | undefined;
-    } | undefined;
+    readonly ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly permissions:
+        | {
+              user?: string[] | import('../main.js').PermissionNames[] | undefined;
+              client?: string[] | import('../main.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
     readonly fileType: 'MessageCommand';
     readonly filePath: string;
     readonly client: typeof XernerxClient;
@@ -39,4 +45,4 @@ export default class MessageCommandBuilder {
     conditions<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
     exec<T>(message: XernerxMessage, { args, flags }: MessageCommandArguments): Promise<void | any | T>;
 }
-//# sourceMappingURL=MessageCommandBuilder.d.ts.map
+//# sourceMappingURL=MessageCommandBuilder.d.ts.map

package/dist/build/MessageCommandBuilder.js

@@ -8,38 +8,38 @@ export default class MessageCommandBuilder {
         this.flags = options.flags;
         options = z
             .object({
-            name: z.string(),
-            aliases: z.array(z.string()).default([]),
-            description: z.string().or(z.null()).default(null),
-            usage: z.string().or(z.null()).default(null),
-            info: z.string().or(z.null()).default(null),
-            category: z.string().or(z.null()).default(null),
-            cooldown: z.number().or(z.null()).default(null),
-            prefix: z.array(z.string()).or(z.string()).default([]),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
+                name: z.string(),
+                aliases: z.array(z.string()).default([]),
+                description: z.string().or(z.null()).default(null),
+                usage: z.string().or(z.null()).default(null),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                cooldown: z.number().or(z.null()).default(null),
+                prefix: z.array(z.string()).or(z.string()).default([]),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
             })
-                .default({}),
-            strict: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
-            })
-                .default({}),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
-            })
-                .default({}),
-        })
             .parse(options);
         this.name = options.name;
         this.aliases = options.aliases;
@@ -55,7 +55,7 @@ export default class MessageCommandBuilder {
         this.permissions = options.permissions;
         this.client = XernerxClient;
     }
-    async conditions(message, { args, flags }) { }
-    async exec(message, { args, flags }) { }
+    async conditions(message, { args, flags }) {}
+    async exec(message, { args, flags }) {}
 }
-//# sourceMappingURL=MessageCommandBuilder.js.map
+//# sourceMappingURL=MessageCommandBuilder.js.map

package/dist/build/SlashCommandBuilder.d.ts

@@ -12,37 +12,51 @@ export default class SlashCommandBuilder {
     readonly info: string | null | undefined;
     readonly category: string | null | undefined;
     readonly cooldown: number | null | undefined;
-    readonly ignore: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly strict: {
-        owner?: boolean | undefined;
-        users?: string[] | undefined;
-        channels?: string[] | undefined;
-        guilds?: string[] | undefined;
-    } | undefined;
-    readonly permissions: {
-        user?: string[] | import("../types/types.js").PermissionNames[] | undefined;
-        client?: string[] | import("../types/types.js").PermissionNames[] | undefined;
-        dm?: boolean | undefined;
-    } | undefined;
-    readonly defer: {
-        reply?: boolean | undefined;
-        ephemeral?: boolean | undefined;
-        fetchReply?: boolean | undefined;
-    } | undefined;
+    readonly ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly permissions:
+        | {
+              user?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              client?: string[] | import('../types/types.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    readonly defer:
+        | {
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetchReply?: boolean | undefined;
+          }
+        | undefined;
     readonly fileType: 'SlashCommand';
     readonly filePath: string;
     readonly client: typeof XernerxClient;
     constructor(id: string, options: SlashCommandOptions);
     autocomplete<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, focused: T, options: T[]): Promise<void | any | T>;
-    conditions<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, { args, subcommand, group }: SlashCommandArguments): Promise<void | any | T>;
-    exec<T>(interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>, { args, subcommand, group }: SlashCommandArguments): Promise<void | any | T>;
+    conditions<T>(
+        interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
+        { args, subcommand, group }: SlashCommandArguments
+    ): Promise<void | any | T>;
+    exec<T>(
+        interaction: XernerxInteraction<XernerxSlashInteraction | XernerxUserContextInteraction | XernerxMessageContextInteraction>,
+        { args, subcommand, group }: SlashCommandArguments
+    ): Promise<void | any | T>;
     private addArguments;
     private addSubcommands;
     private addSubcommandGroups;
 }
-//# sourceMappingURL=SlashCommandBuilder.d.ts.map
+//# sourceMappingURL=SlashCommandBuilder.d.ts.map

package/dist/build/SlashCommandBuilder.js

@@ -21,44 +21,44 @@ export default class SlashCommandBuilder {
         }
         options = z
             .object({
-            name: z.string(),
-            description: z.string(),
-            usage: z.string().or(z.null()).default(null),
-            info: z.string().or(z.null()).default(null),
-            category: z.string().or(z.null()).default(null),
-            number: z.number().or(z.null()).default(null),
-            channelType: z.array(z.number()).or(z.null()).default(null),
-            ignore: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
+                name: z.string(),
+                description: z.string(),
+                usage: z.string().or(z.null()).default(null),
+                info: z.string().or(z.null()).default(null),
+                category: z.string().or(z.null()).default(null),
+                number: z.number().or(z.null()).default(null),
+                channelType: z.array(z.number()).or(z.null()).default(null),
+                ignore: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                strict: z
+                    .object({
+                        owner: z.boolean().default(false),
+                        users: z.array(z.string()).default([]),
+                        channels: z.array(z.string()).default([]),
+                        guilds: z.array(z.string()).default([]),
+                    })
+                    .default({}),
+                permissions: z
+                    .object({
+                        user: z.array(z.string()).default([]),
+                        client: z.array(z.string()).default([]),
+                        dm: z.boolean().default(true),
+                    })
+                    .default({}),
+                defer: z
+                    .object({
+                        reply: z.boolean().default(false),
+                        ephemeral: z.boolean().default(false),
+                        fetch: z.boolean().default(false),
+                    })
+                    .default({}),
             })
-                .default({}),
-            strict: z
-                .object({
-                owner: z.boolean().default(false),
-                users: z.array(z.string()).default([]),
-                channels: z.array(z.string()).default([]),
-                guilds: z.array(z.string()).default([]),
-            })
-                .default({}),
-            permissions: z
-                .object({
-                user: z.array(z.string()).default([]),
-                client: z.array(z.string()).default([]),
-                dm: z.boolean().default(true),
-            })
-                .default({}),
-            defer: z
-                .object({
-                reply: z.boolean().default(false),
-                ephemeral: z.boolean().default(false),
-                fetch: z.boolean().default(false),
-            })
-                .default({}),
-        })
             .parse(options);
         this.name = options.name;
         this.description = options.description;
@@ -72,9 +72,9 @@ export default class SlashCommandBuilder {
         this.defer = options.defer;
         this.client = XernerxClient;
     }
-    async autocomplete(interaction, focused, options) { }
-    async conditions(interaction, { args, subcommand, group }) { }
-    async exec(interaction, { args, subcommand, group }) { }
+    async autocomplete(interaction, focused, options) {}
+    async conditions(interaction, { args, subcommand, group }) {}
+    async exec(interaction, { args, subcommand, group }) {}
     addArguments(command, args) {
         for (const argument of args) {
             let slashCommandArgumentType = `${argument.type.charAt(0).toUpperCase()}${argument.type.slice(1).toLowerCase()}`;
@@ -85,9 +85,11 @@ export default class SlashCommandBuilder {
                     .setRequired(argument.required || false);
                 if (slashCommandArgumentType === 'String') {
                     if (argument.choices)
-                        option.setChoices(...argument.choices.map((choices) => {
-                            return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
-                        }));
+                        option.setChoices(
+                            ...argument.choices.map((choices) => {
+                                return { name: Object.keys(choices).at(0), value: Object.values(choices).at(0) };
+                            })
+                        );
                     option.setAutocomplete(argument.autocomplete || false);
                 }
                 return option;
@@ -97,18 +99,16 @@ export default class SlashCommandBuilder {
     addSubcommands(method, subcommands) {
         for (const subcommand of subcommands) {
             let sub = new SlashCommandSubcommandBuilder().setName(subcommand.name).setDescription(subcommand.description);
-            if (subcommand.args && subcommand?.args?.length > 0)
-                this.addArguments(sub, subcommand.args);
+            if (subcommand.args && subcommand?.args?.length > 0) this.addArguments(sub, subcommand.args);
             method.addSubcommand(sub);
         }
     }
     addSubcommandGroups(groups) {
         for (const group of groups) {
             let subcommandGroup = new SlashCommandSubcommandGroupBuilder().setName(group.name).setDescription(group.description);
-            if (group.subcommands?.length > 0)
-                this.addSubcommands(subcommandGroup, group.subcommands);
+            if (group.subcommands?.length > 0) this.addSubcommands(subcommandGroup, group.subcommands);
             this.data.addSubcommandGroup(subcommandGroup);
         }
     }
 }
-//# sourceMappingURL=SlashCommandBuilder.js.map
+//# sourceMappingURL=SlashCommandBuilder.js.map

package/dist/build/XernerxContextCommand.d.ts

@@ -0,0 +1,51 @@
+import { ContextMenuCommandBuilder } from 'discord.js';
+import XernerxClient from '../client/XernerxClient.js';
+import { XernerxMessageContextInteraction, XernerxUserContextInteraction } from '../types/extenders.js';
+import { ContextCommandArguments, ContextCommandOptions } from '../types/interfaces.js';
+export default class XernerxContextCommand {
+    readonly id: string;
+    readonly data: ContextMenuCommandBuilder;
+    readonly name: string;
+    readonly type: 'user' | 'message';
+    readonly description: string | null | undefined;
+    readonly usage: string | null | undefined;
+    readonly info: string | null | undefined;
+    readonly category: string | null | undefined;
+    readonly cooldown: number | null | undefined;
+    readonly ignore:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly strict:
+        | {
+              owner?: boolean | undefined;
+              users?: string[] | undefined;
+              channels?: string[] | undefined;
+              guilds?: string[] | undefined;
+          }
+        | undefined;
+    readonly permissions:
+        | {
+              user?: string[] | import('../main.js').PermissionNames[] | undefined;
+              client?: string[] | import('../main.js').PermissionNames[] | undefined;
+              dm?: boolean | undefined;
+          }
+        | undefined;
+    readonly defer:
+        | {
+              reply?: boolean | undefined;
+              ephemeral?: boolean | undefined;
+              fetchReply?: boolean | undefined;
+          }
+        | undefined;
+    readonly fileType: 'ContextCommand';
+    readonly filePath: string;
+    readonly client: typeof XernerxClient;
+    constructor(id: string, options: ContextCommandOptions);
+    exec<T>(interaction: XernerxUserContextInteraction | XernerxMessageContextInteraction, args: ContextCommandArguments<'user' | 'message'>): Promise<void | any | T>;
+}
+//# sourceMappingURL=XernerxContextCommand.d.ts.map

package/dist/build/XernerxContextCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XernerxContextCommand.d.ts","sourceRoot":"","sources":["../../src/build/XernerxContextCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAGvD,OAAO,aAAa,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAExF,MAAM,CAAC,OAAO,OAAO,qBAAqB;IACtC,SAAwB,EAAE,SAAC;IAC3B,SAAwB,IAAI,4BAAC;IAC7B,SAAwB,IAAI,SAAC;IAC7B,SAAwB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACjD,SAAwB,WAAW,4BAAC;IACpC,SAAwB,KAAK,4BAAC;IAC9B,SAAwB,IAAI,4BAAC;IAC7B,SAAwB,QAAQ,4BAAC;IACjC,SAAwB,QAAQ,4BAAC;IACjC,SAAwB,MAAM;;;;;kBAAC;IAC/B,SAAwB,MAAM;;;;;kBAAC;IAC/B,SAAwB,WAAW;;;;kBAAC;IACpC,SAAwB,KAAK;;;;kBAAC;IAC9B,SAAwB,QAAQ,EAAE,gBAAgB,CAAC;IACnD,SAAwB,QAAQ,EAAE,MAAM,CAAC;IACzC,SAAwB,MAAM,uBAAC;gBAEZ,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAgFhD,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,6BAA6B,GAAG,gCAAgC,EAAE,IAAI,EAAE,uBAAuB,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC;CAClL"}