node-leek 1.0.0

package/dist/node-leek-client/leek-wars-client.js

@@ -0,0 +1,541 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeekWarsClient = void 0;
+const defaultApi_js_1 = require("../codegen/api/defaultApi.js");
+const aicode_js_1 = require("../codegen/model/aicode.js");
+const fightResult_js_1 = require("../codegen/model/fightResult.js");
+const createFile200ResponseAi_js_1 = require("../codegen/model/createFile200ResponseAi.js");
+const SocketMessage_js_1 = require("./leekwars-frontend/SocketMessage.js");
+const Notification_js_1 = require("./leekwars-frontend/Notification.js");
+const Items_js_1 = require("./leekwars-frontend/Items.js");
+function getSetterOf(header, attribute) {
+    return header.find(cookie => cookie.trim().startsWith(`${attribute}=`) && !cookie.startsWith(`${attribute}=deleted;`)) ?? `${attribute}=;`;
+}
+function getCookieToken(header) {
+    const cookie = getSetterOf(header ?? [], "token");
+    if (!cookie.includes("token="))
+        return "";
+    const value = cookie.split(";")[0].split("token=")[1];
+    return value !== undefined ? value : "";
+}
+function getPhpsessidToken(header) {
+    const cookie = getSetterOf(header ?? [], "PHPSESSID");
+    if (!cookie.includes("PHPSESSID="))
+        return "";
+    const value = cookie.split(";")[0].split("PHPSESSID=")[1];
+    return value !== undefined ? value : "";
+}
+class LeekWarsClient {
+    apiClient;
+    ready = false;
+    username;
+    password;
+    readonly;
+    socket;
+    token = "";
+    phpsessid = "";
+    currentRoom = "";
+    constructor(username, password, readonly = false) {
+        this.readonly = readonly;
+        this.username = username;
+        this.password = password;
+        this.socket = null;
+        this.apiClient = new defaultApi_js_1.DefaultApi();
+    }
+    async loginOnLeekwars() {
+        return this.apiClient.login({
+            login: this.username,
+            password: this.password,
+            keepConnected: true
+        }).then(async (r) => {
+            this.token = getCookieToken(r.response.headers["set-cookie"]);
+            this.phpsessid = getPhpsessidToken(r.response.headers["set-cookie"]);
+            this.apiClient.setApiKey(defaultApi_js_1.DefaultApiApiKeys.cookieAuth, this.token);
+            this.apiClient.setApiKey(defaultApi_js_1.DefaultApiApiKeys.phpsessid, this.phpsessid);
+            this.ready = true;
+            await this.connectWebSocket();
+            // Add on purpose delay to avoid TOO_MANY_REQUEST
+            await this.sleep(100);
+            return r.body.farmer;
+        })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000).then(() => this.loginOnLeekwars());
+            }
+            console.error("Can't connect " + this.username + " -> [" + err.statusCode + "] " + err.body.error);
+            throw err;
+        });
+    }
+    async close() {
+        this.socket?.close();
+    }
+    async sleep(delay) {
+        return new Promise(resolve => setTimeout(resolve, delay));
+    }
+    async getLeek(leek_id) {
+        if (!this.ready)
+            return null;
+        return this.apiClient.getLeek(leek_id)
+            .then(result => {
+            return result.body;
+        })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000).then(() => this.getLeek(leek_id));
+            }
+            console.error("Can't get Leek " + leek_id + " -> [" + err.statusCode + "] " + err.body.error);
+            return null;
+        });
+    }
+    async buy(item_id, quantity = 1) {
+        if (!this.ready)
+            return null;
+        if (this.readonly) {
+            console.error("Readonly mode, can't buy items");
+            return null;
+        }
+        return this.apiClient.buy({
+            itemId: item_id,
+            quantity: quantity
+        })
+            .then(async (result) => {
+            // Add on purpose delay to avoid TOO_MANY_REQUEST
+            await this.sleep(100);
+            return result.body;
+        })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.buy(item_id, quantity));
+            }
+            console.error("Can't buy " + item_id + " " + quantity + " times -> [" + err.statusCode + "] " + err.body.error);
+            return null;
+        });
+    }
+    async fetchFiles(requests) {
+        if (!this.ready)
+            return [new aicode_js_1.Aicode()];
+        return this.apiClient.getFilesContent({
+            ais: JSON.stringify(requests)
+        })
+            .then(result => result.body)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.fetchFiles(requests));
+            }
+            console.error("fetchFiles(" + requests + ") -> [" + err.statusCode + "] " + err.body.error);
+            return [];
+        });
+    }
+    async fetchFile(ai, timestamp) {
+        if (!this.ready)
+            return new aicode_js_1.Aicode();
+        const request = {};
+        request[ai] = timestamp;
+        return this.fetchFiles(request)
+            .then(result => result[0])
+            .catch(err => {
+            console.error("fetchFile -> [" + err.statusCode + "] " + err.body.error);
+            return new aicode_js_1.Aicode();
+        });
+    }
+    async saveFile(ai_id, code) {
+        if (!this.ready)
+            return 0;
+        if (this.readonly) {
+            console.error("Readonly mode, can't save file");
+            return 0;
+        }
+        return this.apiClient.saveFile({
+            aiId: ai_id,
+            code: code
+        })
+            .then(result => result.body.modified)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.saveFile(ai_id, code));
+            }
+            console.error("saveFile " + ai_id + " (" + code.substring(0, 20) + ") -> [" + err.statusCode + "] " + err.body.error);
+            return 0;
+        });
+    }
+    async createFile(folder_id, name, version = 4) {
+        if (!this.ready)
+            return new createFile200ResponseAi_js_1.CreateFile200ResponseAi();
+        if (this.readonly) {
+            console.error("Readonly mode, can't create file");
+            return new createFile200ResponseAi_js_1.CreateFile200ResponseAi();
+        }
+        return this.apiClient.createFile({
+            folderId: folder_id,
+            name: name,
+            version: version
+        })
+            .then(result => result.body.ai)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.createFile(folder_id, name, version));
+            }
+            console.error("createFile " + name + " (parent is " + folder_id + ") -> [" + err.statusCode + "] " + err.body.error);
+            return new createFile200ResponseAi_js_1.CreateFile200ResponseAi();
+        });
+    }
+    async createFolder(folder_id, name) {
+        if (!this.ready)
+            return -1;
+        if (this.readonly) {
+            console.error("Readonly mode, can't create folder");
+            return -1;
+        }
+        return this.apiClient.createFolder({
+            folderId: folder_id,
+            name: name
+        })
+            .then(result => result.body.id)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.createFolder(folder_id, name));
+            }
+            console.error("createFolder " + name + " (parent is " + folder_id + ") -> [" + err.statusCode + "] " + err.body.error);
+            return -1;
+        });
+    }
+    async deleteFile(ai_id) {
+        if (!this.ready)
+            return;
+        if (this.readonly) {
+            console.error("Readonly mode, can't delete file");
+            return;
+        }
+        return this.apiClient.deleteFile({
+            aiId: ai_id,
+        })
+            .then(result => { })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.deleteFile(ai_id));
+            }
+            console.error("deleteFile " + ai_id + " -> [" + err.statusCode + "] " + err.body.error);
+        });
+    }
+    async deleteFolder(folder_id) {
+        if (!this.ready)
+            return;
+        if (this.readonly) {
+            console.error("Readonly mode, can't delete folder");
+            return;
+        }
+        return this.apiClient.deleteFolder({
+            folderId: folder_id,
+        })
+            .then(result => result.body)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.deleteFolder(folder_id));
+            }
+            console.error("deleteFolder " + folder_id + " -> [" + err.statusCode + "] " + err.body.error);
+        });
+    }
+    async getSoloOpponents(leek_id) {
+        return this.apiClient.getSoloOpponents(leek_id)
+            .then(result => result.body.opponents)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.getSoloOpponents(leek_id));
+            }
+            console.error("getSoloOpponents " + leek_id + " -> [" + err.statusCode + "] " + err.body.error);
+            return [];
+        });
+    }
+    async startSoloFight(leek_id, target_id) {
+        if (!this.ready)
+            return -1;
+        if (this.readonly) {
+            console.error("Readonly mode, can't start fight");
+            return -1;
+        }
+        return this.apiClient.startSoloFight({
+            leekId: leek_id,
+            targetId: target_id
+        })
+            .then(async (result) => {
+            // Add on purpose delay to avoid TOO_MANY_REQUEST
+            await this.sleep(100);
+            return result.body.fight;
+        })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.startSoloFight(leek_id, target_id));
+            }
+            console.error("startSoloFight " + leek_id + " vs " + target_id + " -> [" + err.statusCode + "] " + err.body);
+            return -1;
+        });
+    }
+    async getFarmerOpponents() {
+        if (!this.ready)
+            return [];
+        return this.apiClient.getFarmerOpponents()
+            .then(result => result.body.opponents)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.getFarmerOpponents());
+            }
+            console.error("getFarmerOpponents -> [" + err.statusCode + "] " + err.body.error);
+            return [];
+        });
+    }
+    async startFarmerFight(target_id) {
+        if (!this.ready)
+            return -1;
+        if (this.readonly) {
+            console.error("Readonly mode, can't start fight");
+            return -1;
+        }
+        return this.apiClient.startFarmerFight({
+            targetId: target_id
+        })
+            .then(result => result.body.fight)
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.startFarmerFight(target_id));
+            }
+            console.error("startFarmerFight vs " + target_id + " -> [" + err.statusCode + "] " + err.body);
+            return -1;
+        });
+    }
+    async getFight(fight_id) {
+        if (!this.ready)
+            return new fightResult_js_1.FightResult();
+        return this.apiClient.getFight(fight_id)
+            .then(async (result) => {
+            await this.sleep(75);
+            return result.body;
+        })
+            .catch(err => {
+            if (err.statusCode == 429) { // TOO MANY REQUEST
+                return this.sleep(15000)
+                    .then(() => this.getFight(fight_id));
+            }
+            console.error("getFight " + fight_id + " -> [" + err.statusCode + "] " + err.body.error);
+            return new fightResult_js_1.FightResult();
+        });
+    }
+    async createBossRoom(bossId = 1, locked = false, leeks = []) {
+        const r = `[${SocketMessage_js_1.SocketMessage.GARDEN_BOSS_CREATE_SQUAD}, ${bossId}, ${locked}, [${leeks}]]`;
+        this.socket?.send(r);
+        console.log("Create room : ", r);
+    }
+    async joinBossRoom(roomId, leeks = []) {
+        const r = `[${SocketMessage_js_1.SocketMessage.GARDEN_BOSS_JOIN_SQUAD}, "${roomId}", [${leeks}]]`;
+        this.socket?.send(r);
+        console.log("Join room : ", r);
+    }
+    async startRoomFight() {
+        const r = `[${SocketMessage_js_1.SocketMessage.GARDEN_BOSS_ATTACK}]`;
+        this.socket?.send(r);
+        console.log("Start room : ", r);
+    }
+    async recieveNotification(message) {
+        switch (message.type) {
+            case Notification_js_1.NotificationType.TROPHY_UNLOCKED:
+                console.log(`[WS ${this.username}] Trophy unlocked :`, message);
+                break;
+            case Notification_js_1.NotificationType.UP_LEVEL:
+                console.log(`[WS ${this.username}] Leek ${message.parameters[0]} reached level ${message.parameters[1]} (${message.parameters[2]} capitals to spend)`, message);
+                this.on_level_up(message.parameters[0], message.parameters[1], message.parameters[2]);
+                break;
+            case Notification_js_1.NotificationType.BOSS_STARTED:
+                // console.log(`[WS ${this.username}] Boss fight started`);
+                break;
+            default:
+                console.log(`[WS ${this.username}] Notification :`, message);
+                break;
+        }
+    }
+    async connectWebSocket() {
+        if (!this.ready)
+            return;
+        this.socket = new WebSocket('wss://leekwars.com/ws', [
+            'leek-wars',
+            this.token
+        ]),
+            this.socket.onopen = () => {
+                console.log("Websocket connected !");
+                // o.M.commit('invalidate-chats'),
+                //     o.M.commit('wsconnected'),
+                //     this.retry_count = 10,
+                //     this.retry_delay = 1000;
+                // for (const e of this.queue) this.send(e);
+                // this.queue = [],
+                //     r.H.battleRoyale.init(),
+                //     r.H.bossSquads.init()
+            },
+            this.socket.onclose = () => {
+                console.log("Websocket closed ! ");
+                // if (
+                //     o.M.getters.admin ||
+                //     r.H.LOCAL ||
+                //     r.H.DEV ||
+                //     window.__FARMER__ &&
+                //     1 === window.__FARMER__.farmer.id
+                // ) {
+                //     const e = '[WS] fermée';
+                //     console.error(e)
+                // }
+                // o.M.commit('wsclose'),
+                //     this.retry()
+            },
+            this.socket.onerror = e => {
+                console.error(`[WS ${this.username}] erreur`, e);
+            },
+            this.socket.onmessage = msg => {
+                const json = JSON.parse(msg.data);
+                const id = json[0];
+                const data = json[1];
+                const request_id = json[2];
+                switch (id) {
+                    case SocketMessage_js_1.SocketMessage.PONG: {
+                        console.log(`"[WS ${this.username}] received PONG`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.NOTIFICATION_RECEIVE: {
+                        this.recieveNotification({ id: data[0], type: data[1], parameters: data[2], new: true });
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.LUCKY: {
+                        // NOTHING TO DO
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.FAKE_LUCKY: {
+                        // CLICK ON LUCKY
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.BATTLE_ROYALE_CHAT_NOTIF: {
+                        console.log(`[WS ${this.username}] received BATTLE_ROYALE_CHAT_NOTIF`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.BATTLE_ROYALE_UPDATE: {
+                        console.log(`[WS ${this.username}] received BATTLE_ROYALE_UPDATE`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.BATTLE_ROYALE_START: {
+                        console.log(`[WS ${this.username}] received BATTLE_ROYALE_START`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.BATTLE_ROYALE_LEAVE: {
+                        console.log(`[WS ${this.username}] received BATTLE_ROYALE_LEAVE`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_QUEUE: {
+                        console.log(`[WS ${this.username}] received GARDEN_QUEUE`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.FIGHT_PROGRESS: {
+                        console.log(`[WS ${this.username}] received FIGHT_PROGRESS`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.TOURNAMENT_UPDATE: {
+                        console.log(`[WS ${this.username}] received TOURNAMENT_UPDATE`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.UPDATE_HABS: {
+                        console.log(`[WS ${this.username}] +` + data[0] + " 🪙");
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.UPDATE_LEEK_XP: {
+                        console.log(`[WS ${this.username}] +` + data[1] + " xp");
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.UPDATE_LEEK_TALENT: {
+                        console.log(`[WS ${this.username}] ` + (data[1] > 0 ? "+" : "") + data[1] + " talents");
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.UPDATE_FARMER_TALENT: {
+                        console.log(`[WS ${this.username}] ` + (data[1] > 0 ? "+" : "") + data[1] + " farmer talents");
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.UPDATE_TEAM_TALENT: {
+                        console.log(`[WS ${this.username}] ` + (data[1] > 0 ? "+" : "") + data[1] + " team talents");
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.ADD_RESOURCE: {
+                        // console.log(`[WS ${this.username}] received ADD_RESOURCE`, data);
+                        console.log(`[WS ${this.username}] ` + (data[2] > 1 ? data[2] : "") + " " + Items_js_1.ITEMS[data[0]]?.name);
+                        // console.log("add resource", data)
+                        // const template = data[0]
+                        // const id = data[1]
+                        // const quantity = data[2]
+                        // const item = "" // TODO LeekWars.items[data[0]]
+                        // const time = data[3]
+                        // if (item) {
+                        //     //store.commit('add-inventory', { type: item.type, template, id, quantity, time })
+                        // }
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_SQUADS: {
+                        // console.log(`[WS ${this.username}] received GARDEN_BOSS_SQUADS`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_SQUAD_JOINED: {
+                        console.log(`[WS ${this.username}] received GARDEN_BOSS_SQUAD_JOINED`);
+                        this.currentRoom = data.id;
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_SQUAD: {
+                        // console.log(`[WS ${this.username}] received GARDEN_BOSS_SQUAD`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_NO_SUCH_SQUAD: {
+                        console.log(`[WS ${this.username}] received GARDEN_BOSS_NO_SUCH_SQUAD`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_STARTED: {
+                        console.log(`[WS ${this.username}] received GARDEN_BOSS_STARTED`);
+                        this.currentRoom = "";
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.GARDEN_BOSS_LEFT: {
+                        console.log(`[WS ${this.username}] received GARDEN_BOSS_LEFT`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.CONSOLE_RESULT: {
+                        console.log(`[WS ${this.username}] received CONSOLE_RESULT`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.CONSOLE_ERROR: {
+                        console.log(`[WS ${this.username}] received CONSOLE_ERROR`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.CONSOLE_LOG: {
+                        console.log(`[WS ${this.username}] received CONSOLE_LOG`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.EDITOR_ANALYZE: {
+                        console.log(`[WS ${this.username}] received EDITOR_ANALYZE`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.EDITOR_HOVER: {
+                        console.log(`[WS ${this.username}] received EDITOR_HOVER`, data);
+                        break;
+                    }
+                    case SocketMessage_js_1.SocketMessage.EDITOR_COMPLETE: {
+                        console.log(`[WS ${this.username}] received EDITOR_COMPLETE`, data);
+                        break;
+                    }
+                }
+            };
+    }
+    // Make this an observable
+    on_level_up = (_) => { };
+}
+exports.LeekWarsClient = LeekWarsClient;

package/dist/node-leek-client/leekwars-frontend/Item.d.ts

@@ -0,0 +1,80 @@
+declare enum ItemType {
+    ALL = 0,
+    WEAPON = 1,
+    CHIP = 2,
+    POTION = 3,
+    HAT = 4,
+    POMP = 5,
+    FIGHT_PACK = 6,
+    RESOURCE = 7,
+    COMPONENT = 8,
+    SCHEME = 9
+}
+declare const ItemTypes: ItemType[];
+export { ItemType, ItemTypes };
+declare class Item {
+    id: number;
+    template: number;
+    quantity: number;
+    time: number;
+}
+declare class ItemTemplate {
+    id: number;
+    name: string;
+    type: ItemType;
+    price: number | null;
+    crystals: number | null;
+    sellable: boolean;
+    level: number;
+    params: any;
+    buyable: boolean;
+    public: boolean;
+    singleton: boolean;
+    trophy: number | null;
+    market: boolean;
+    buyable_crystals: boolean;
+    rarity: number;
+    leeks?: number[];
+    leek_count?: number;
+    farmer_count?: number;
+    sell_price?: number;
+    seen?: boolean;
+}
+declare const ITEM_CATEGORY_NAME: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+};
+declare const ITEM_TYPE_NAME: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+};
+declare const ITEM_TYPE_ICONS: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+};
+export { Item, ItemTemplate, ITEM_CATEGORY_NAME, ITEM_TYPE_NAME, ITEM_TYPE_ICONS };
+//# sourceMappingURL=Item.d.ts.map

package/dist/node-leek-client/leekwars-frontend/Item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Item.d.ts","sourceRoot":"","sources":["../../../src/node-leek-client/leekwars-frontend/Item.ts"],"names":[],"mappings":"AAAA,aAAK,QAAQ;IACT,GAAG,IAAI;IACP,MAAM,IAAI;IACV,IAAI,IAAI;IACR,MAAM,IAAI;IACV,GAAG,IAAI;IACP,IAAI,IAAI;IACR,UAAU,IAAI;IACd,QAAQ,IAAI;IACZ,SAAS,IAAI;IACb,MAAM,IAAI;CACb;AACD,QAAA,MAAM,SAAS,YAA4K,CAAA;AAE3L,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAA;AAE9B,cAAM,IAAI;IACC,EAAE,EAAG,MAAM,CAAA;IACX,QAAQ,EAAG,MAAM,CAAA;IACjB,QAAQ,EAAG,MAAM,CAAA;IACjB,IAAI,EAAG,MAAM,CAAA;CACvB;AAED,cAAM,YAAY;IACP,EAAE,EAAG,MAAM,CAAA;IACX,IAAI,EAAG,MAAM,CAAA;IACb,IAAI,EAAG,QAAQ,CAAA;IACf,KAAK,EAAG,MAAM,GAAG,IAAI,CAAA;IACrB,QAAQ,EAAG,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAG,OAAO,CAAA;IAClB,KAAK,EAAG,MAAM,CAAA;IACd,MAAM,EAAG,GAAG,CAAA;IACZ,OAAO,EAAG,OAAO,CAAA;IACjB,MAAM,EAAG,OAAO,CAAA;IAChB,SAAS,EAAG,OAAO,CAAA;IACnB,MAAM,EAAG,MAAM,GAAG,IAAI,CAAA;IACtB,MAAM,EAAG,OAAO,CAAA;IAChB,gBAAgB,EAAG,OAAO,CAAA;IAC1B,MAAM,EAAG,MAAM,CAAA;IAEf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAEhB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,QAAA,MAAM,kBAAkB;;;;;;;;;;;CAWvB,CAAA;AAED,QAAA,MAAM,cAAc;;;;;;;;;;;CAWnB,CAAA;AAED,QAAA,MAAM,eAAe;;;;;;;;;;;CAWpB,CAAA;AAED,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,eAAe,EAAE,CAAA"}