osrs-tools 2.3.0 → 2.3.3

package/dist/out-tsc/test/unit/slayer/model/Assignment.test.js

@@ -0,0 +1,14 @@
+import { SlayerLevelRequirement } from '../../../../source/runescape/model/Requirement';
+import { Assignment } from '../../../../source/runescape/model/slayer/Assignment';
+import { Task } from '../../../../source/runescape/model/slayer/Task';
+describe('Assignment', () => {
+    it('should set properties correctly via constructor', () => {
+        const requirements = [new SlayerLevelRequirement(50)];
+        const task = new Task('Aberrant Spectres', 10, 20, requirements, 5, 15);
+        const assignment = new Assignment(task.name, 10, requirements, task.extendedAmountMin, task.extendedAmountMax);
+        expect(assignment.name).toBe('Aberrant Spectres');
+        expect(assignment.requirements).toEqual(requirements);
+        expect(assignment.getName()).toBe('Aberrant Spectres');
+        expect(assignment.getQuantity()).toBe(10);
+    });
+});

package/dist/out-tsc/test/unit/slayer/model/SlayerUnlock.test.js

@@ -0,0 +1,38 @@
+import { SlayerUnlock, SlayerUnlocks } from '../../../../source/runescape/model/slayer/SlayerUnlock';
+describe('SlayerUnlock', () => {
+    it('should create a SlayerUnlock instance with correct properties', () => {
+        const unlock = new SlayerUnlock('Test Unlock', 100, 'Test description');
+        expect(unlock.name).toBe('Test Unlock');
+        expect(unlock.cost).toBe(100);
+        expect(unlock.description).toBe('Test description');
+    });
+    it('should have a predefined list of SlayerUnlocks', () => {
+        expect(SlayerUnlocks).toBeInstanceOf(Array);
+        expect(SlayerUnlocks.length).toBeGreaterThan(0);
+    });
+    it('should contain specific SlayerUnlocks with correct properties', () => {
+        const gargoyleSmasher = SlayerUnlocks.find(unlock => unlock.name === 'Gargoyle smasher');
+        expect(gargoyleSmasher).toBeDefined();
+        expect(gargoyleSmasher?.cost).toBe(120);
+        expect(gargoyleSmasher?.description).toBe('Gargoyles are automatically dealt the finishing blow if the player has a Rock hammer in their inventory.');
+        const likeABoss = SlayerUnlocks.find(unlock => unlock.name === 'Like a boss');
+        expect(likeABoss).toBeDefined();
+        expect(likeABoss?.cost).toBe(200);
+        expect(likeABoss?.description).toBe('Konar, Duradel, Krystilia and Nieve will be able to assign boss monsters as your task, excluding the Corporeal Beast.');
+    });
+    it('should not contain duplicate SlayerUnlock names', () => {
+        const names = SlayerUnlocks.map(unlock => unlock.name);
+        const uniqueNames = new Set(names);
+        expect(names.length).toBe(uniqueNames.size);
+    });
+    it('should have all SlayerUnlocks with a positive cost', () => {
+        SlayerUnlocks.forEach(unlock => {
+            expect(unlock.cost).toBeGreaterThan(0);
+        });
+    });
+    it('should have all SlayerUnlocks with a non-empty description', () => {
+        SlayerUnlocks.forEach(unlock => {
+            expect(unlock.description).toBeTruthy();
+        });
+    });
+});

package/dist/out-tsc/test/unit/slayer/model/Task.test.js

@@ -0,0 +1,122 @@
+import { SlayerLevelRequirement } from '../../../../source/runescape/model/Requirement';
+import { Task } from '../../../../source/runescape/model/slayer/Task';
+describe('Task', () => {
+    let mockRequirements;
+    beforeEach(() => {
+        mockRequirements = [new SlayerLevelRequirement(75)];
+    });
+    describe('constructor', () => {
+        it('should create a Task with minimum required properties', () => {
+            const task = new Task('Abyssal demons', 125, 200, mockRequirements);
+            expect(task.name).toBe('Abyssal demons');
+            expect(task.amountMin).toBe(125);
+            expect(task.amountMax).toBe(200);
+            expect(task.requirements).toEqual(mockRequirements);
+            expect(task.weight).toBe(1); // default value
+            expect(task.alternatives).toEqual([]); // default value
+            expect(task.combatLevels).toEqual([]); // default value
+            expect(task.slayerExp).toBe(0); // default value
+            expect(task.locations).toEqual([]); // default value
+            expect(task.wildernessLevels).toEqual([]); // default value
+            expect(task.bosses).toEqual([]); // default value
+        });
+        it('should create a Task with extended amounts', () => {
+            const task = new Task('Abyssal demons', 125, 200, mockRequirements, 200, 300);
+            expect(task.extendedAmountMin).toBe(200);
+            expect(task.extendedAmountMax).toBe(300);
+        });
+        it('should create a Task with all optional properties', () => {
+            const task = new Task('Abyssal demons', 125, 200, mockRequirements, 200, 300, ['Greater demons'], 8, [124], 300, ['Slayer Tower'], [0], ['Abyssal Sire']);
+            expect(task.name).toBe('Abyssal demons');
+            expect(task.amountMin).toBe(125);
+            expect(task.amountMax).toBe(200);
+            expect(task.requirements).toEqual(mockRequirements);
+            expect(task.extendedAmountMin).toBe(200);
+            expect(task.extendedAmountMax).toBe(300);
+            expect(task.alternatives).toEqual(['Greater demons']);
+            expect(task.weight).toBe(8);
+            expect(task.combatLevels).toEqual([124]);
+            expect(task.slayerExp).toBe(300);
+            expect(task.locations).toEqual(['Slayer Tower']);
+            expect(task.wildernessLevels).toEqual([0]);
+            expect(task.bosses).toEqual(['Abyssal Sire']);
+        });
+    });
+    describe('methods', () => {
+        let task;
+        beforeEach(() => {
+            task = new Task('Abyssal demons', 125, 200, mockRequirements, 200, 300, ['Greater demons'], 8, [124], 300, ['Slayer Tower'], [0], ['Abyssal Sire']);
+        });
+        it('should return correct name via getName()', () => {
+            expect(task.getName()).toBe('Abyssal demons');
+        });
+        it('should return correct weight via getWeight()', () => {
+            expect(task.getWeight()).toBe(8);
+        });
+        it('should return correct min amount via getAmountMin()', () => {
+            expect(task.getAmountMin()).toBe(125);
+        });
+        it('should return correct max amount via getAmountMax()', () => {
+            expect(task.getAmountMax()).toBe(200);
+        });
+        it('should return correct requirements via getRequirements()', () => {
+            expect(task.getRequirements()).toEqual(mockRequirements);
+        });
+        it('should return correct alternatives via getAlternatives()', () => {
+            expect(task.getAlternatives()).toEqual(['Greater demons']);
+        });
+        it('should handle empty alternatives array', () => {
+            const taskWithEmptyAlternatives = new Task('Abyssal demons', 125, 200, mockRequirements, null, null, []);
+            expect(taskWithEmptyAlternatives.getAlternatives()).toEqual([]);
+        });
+        it('should convert to JSON correctly via toJSON()', () => {
+            const json = task.toJSON();
+            expect(json).toEqual({
+                alternatives: ['Greater demons'],
+                amountMax: 200,
+                amountMin: 125,
+                bosses: ['Abyssal Sire'],
+                combatLevels: [124],
+                extendedAmountMax: 300,
+                extendedAmountMin: 200,
+                locations: ['Slayer Tower'],
+                name: 'Abyssal demons',
+                requirements: [new SlayerLevelRequirement(75)],
+                slayerExp: 300,
+                weight: 8,
+                wildernessLevels: [0],
+            });
+        });
+        it('should convert to string correctly via toString()', () => {
+            expect(task.toString()).toBe('Task{ name: Abyssal demons }');
+        });
+    });
+    describe('static methods', () => {
+        it('should create Task from JSON via fromJSON()', () => {
+            const json = {
+                alternatives: ['Greater demons'],
+                amountMax: 200,
+                amountMin: 125,
+                bosses: ['Abyssal Sire'],
+                combatLevels: [124],
+                extendedAmountMax: 300,
+                extendedAmountMin: 200,
+                locations: ['Slayer Tower'],
+                name: 'Abyssal demons',
+                requirements: mockRequirements,
+                slayerExp: 300,
+                weight: 8,
+                wildernessLevels: [0],
+            };
+            const task = Task.fromJSON(json);
+            expect(task).toBeInstanceOf(Task);
+            expect(task.name).toBe('Abyssal demons');
+            expect(task.amountMin).toBe(125);
+            expect(task.amountMax).toBe(200);
+            expect(task.extendedAmountMin).toBe(200);
+            expect(task.extendedAmountMax).toBe(300);
+            expect(task.alternatives).toEqual(['Greater demons']);
+            expect(task.weight).toBe(8);
+        });
+    });
+});

package/dist/out-tsc/test/unit/tools/experience.test.js

@@ -0,0 +1,31 @@
+import { getExperienceForLevel, getLevelForExperience, LEVEL_TO_EXPERIENCE } from "../../../source/runescape/tools/experience";
+/**
+ * Test the experience module
+ */
+describe("Experience", () => {
+    it("should calculate experience for levels correctly", () => {
+        const levelExpMap = LEVEL_TO_EXPERIENCE;
+        for (const [levelStr, expectedExp] of Object.entries(levelExpMap)) {
+            const level = parseInt(levelStr, 10);
+            expect(getExperienceForLevel(level)).toBe(expectedExp);
+        }
+    });
+    // test getLevelForExperience
+    it("should calculate level for experience correctly", () => {
+        const expLevelMap = LEVEL_TO_EXPERIENCE;
+        const randomExp = [0, 500, 2000, 10000, 50000, 200000, 1000000, 5000000, 13034431];
+        for (const exp of randomExp) {
+            let expectedLevel = 1;
+            for (const [levelStr, levelExp] of Object.entries(expLevelMap)) {
+                const level = parseInt(levelStr, 10);
+                if (levelExp <= exp) {
+                    expectedLevel = level;
+                }
+                else {
+                    break;
+                }
+            }
+            expect(getLevelForExperience(exp)).toBe(expectedLevel);
+        }
+    });
+});

package/dist/out-tsc/test/unit/utils/cache.test.js

@@ -0,0 +1,82 @@
+import { Cache } from '../../../source/runescape/utils/cache';
+describe('Cache', () => {
+    let cache;
+    beforeEach(() => {
+        cache = new Cache();
+    });
+    it('should store and retrieve values', () => {
+        cache.set('key1', 'value1');
+        expect(cache.get('key1')).toBe('value1');
+    });
+    it('should handle non-existent keys', () => {
+        expect(cache.get('nonexistent')).toBeUndefined();
+    });
+    it('should respect max size limit', () => {
+        const smallCache = new Cache({ maxSize: 2 });
+        smallCache.set('key1', 'value1');
+        smallCache.set('key2', 'value2');
+        smallCache.set('key3', 'value3');
+        expect(smallCache.get('key1')).toBeUndefined();
+        expect(smallCache.get('key2')).toBe('value2');
+        expect(smallCache.get('key3')).toBe('value3');
+    });
+    it('should handle TTL expiration', async () => {
+        const ttlCache = new Cache({ ttl: 100 }); // 100ms TTL
+        ttlCache.set('key1', 'value1');
+        expect(ttlCache.get('key1')).toBe('value1');
+        await new Promise(resolve => setTimeout(resolve, 150));
+        expect(ttlCache.get('key1')).toBeUndefined();
+    });
+    it('should allow per-item TTL override', async () => {
+        const ttlCache = new Cache({ ttl: 500 });
+        ttlCache.set('key1', 'value1', 100); // Override with 100ms TTL
+        expect(ttlCache.get('key1')).toBe('value1');
+        await new Promise(resolve => setTimeout(resolve, 150));
+        expect(ttlCache.get('key1')).toBeUndefined();
+    });
+    it('should correctly handle delete operation', () => {
+        cache.set('key1', 'value1');
+        expect(cache.delete('key1')).toBe(true);
+        expect(cache.get('key1')).toBeUndefined();
+        expect(cache.delete('key1')).toBe(false);
+    });
+    it('should clear all items', () => {
+        cache.set('key1', 'value1');
+        cache.set('key2', 'value2');
+        cache.clear();
+        expect(cache.size).toBe(0);
+        expect(cache.get('key1')).toBeUndefined();
+        expect(cache.get('key2')).toBeUndefined();
+    });
+    it('should return valid keys only', async () => {
+        const ttlCache = new Cache({ ttl: 100 });
+        ttlCache.set('key1', 'value1');
+        ttlCache.set('key2', 'value2');
+        expect(ttlCache.keys().sort()).toEqual(['key1', 'key2'].sort());
+        await new Promise(resolve => setTimeout(resolve, 150));
+        expect(ttlCache.keys()).toEqual([]);
+    });
+    it('should correctly prune expired items', async () => {
+        const ttlCache = new Cache({ ttl: 100 });
+        ttlCache.set('key1', 'value1');
+        ttlCache.set('key2', 'value2');
+        await new Promise(resolve => setTimeout(resolve, 150));
+        const pruned = ttlCache.prune();
+        expect(pruned).toBe(2);
+        expect(ttlCache.size).toBe(0);
+    });
+    it('should check existence correctly', () => {
+        cache.set('key1', 'value1');
+        expect(cache.has('key1')).toBe(true);
+        expect(cache.has('nonexistent')).toBe(false);
+    });
+    it('should handle getOrSet correctly', async () => {
+        const factory = jest.fn().mockResolvedValue('computed');
+        const value1 = await cache.getOrSet('key1', factory);
+        expect(value1).toBe('computed');
+        expect(factory).toHaveBeenCalledTimes(1);
+        const value2 = await cache.getOrSet('key1', factory);
+        expect(value2).toBe('computed');
+        expect(factory).toHaveBeenCalledTimes(1); // Factory not called again
+    });
+});

package/package.json

@@ -1,90 +1,99 @@
-{
-    "name": "osrs-tools",
-    "description": "A comprehensive TypeScript library for Old School RuneScape (OSRS) data and utilities, including quest data, skill requirements, and game item information",
-    "version": "2.3.0",
-    "license": "MIT",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "require": "./dist/index.js"
-        }
-    },
-    "sideEffects": false,
-    "files": [
-        "dist/**"
-    ],
-    "engines": {
-        "node": ">=18"
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/jamescer/osrs-tools.git"
-    },
-    "keywords": [
-        "osrs",
-        "runescape",
-        "typescript",
-        "quest",
-        "game-data"
-    ],
-    "scripts": {
-        "build": "tsc -p tsconfig.build.json",
-        "clean": "rimraf dist coverage",
-        "dev": "tsc --watch -p tsconfig.build.json",
-        "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
-        "lint": "eslint \"{src,test}/**/*.ts\" --fix",
-        "runExample": "ts-node examples/ExampleQuest.ts",
-        "scrapeQuestList": "ts-node tools/ScrapeQuestData.ts",
-        "scrapeSlayerData": "ts-node tools/ScrapeSlayerData.ts",
-        "getAccountData": "ts-node tools/GetAccountData.ts",
-        "getQuestDetails": "ts-node tools/GetQuestDetails.ts",
-        "prebuild": "npm run clean",
-        "prepublishOnly": "npm run build && npm test",
-        "test": "jest",
-        "test:coverage": "jest --coverage",
-        "test:watch": "jest --watch",
-        "test:ci": "jest --ci --coverage",
-        "coverage": "jest --coverage && codecov",
-        "postpublish": "git push && git push --tags",
-        "preversion": "npm test",
-        "version": "npm run build && git add dist"
-    },
-    "devDependencies": {
-        "@eslint/eslintrc": "^3.3.1",
-        "@eslint/js": "^8.57.0",
-        "@tsconfig/recommended": "^1.0.11",
-        "@types/jest": "^29.5.14",
-        "@types/node": "^18.19.130",
-        "@typescript-eslint/eslint-plugin": "^7.18.0",
-        "@typescript-eslint/parser": "^7.18.0",
-        "codecov": "^3.8.2",
-        "commitlint": "^17.8.1",
-        "eslint": "^8.57.1",
-        "eslint-config-prettier": "^9.1.2",
-        "eslint-plugin-jest": "^27.9.0",
-        "eslint-plugin-prettier": "^5.5.4",
-        "eslint-plugin-simple-import-sort": "^12.1.1",
-        "eslint-plugin-sort-destructure-keys": "^1.6.0",
-        "eslint-plugin-sort-keys-fix": "^1.1.2",
-        "jest": "^29.7.0",
-        "lint-staged": "^14.0.1",
-        "prettier": "^3.6.2",
-        "rimraf": "^5.0.10",
-        "ts-jest": "^29.4.5",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.9.3"
-    },
-    "lint-staged": {
-        "*.{ts,tsx}": [
-            "eslint --fix",
-            "prettier --write"
-        ]
-    },
-    "commitlint": {
-        "extends": [
-            "@commitlint/config-conventional"
-        ]
-    }
-}
+{
+  "name": "osrs-tools",
+  "version": "2.3.3",
+  "description": "A comprehensive TypeScript library for Old School RuneScape (OSRS) data and utilities, including quest data, skill requirements, and game item information",
+  "license": "MIT",
+  "keywords": [
+    "osrs",
+    "runescape",
+    "typescript",
+    "quest",
+    "game-data"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jamescer/osrs-tools.git"
+  },
+  "homepage": "https://github.com/jamescer/osrs-tools#readme",
+  "bugs": {
+    "url": "https://github.com/jamescer/osrs-tools/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:osrs-tools": "tsc -p tsconfig.json",
+    "build:osrs-tools:npm": "tsc -p tsconfig.build.json",
+    "clean": "rimraf dist",
+    "coverage": "jest --coverage && codecov",
+    "dev": "tsc --watch -p tsconfig.build.json",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "getAccountData": "ts-node tools/GetAccountData.ts",
+    "getQuestDetails": "ts-node tools/GetQuestDetails.ts",
+    "lint": "eslint \"{src,test}/**/*.ts\" --fix",
+    "postpublish": "git push && git push --tags",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build && npm test",
+    "preversion": "npm test",
+    "runExample": "ts-node examples/ExampleQuest.ts",
+    "scrapeQuestList": "ts-node tools/ScrapeQuestData.ts",
+    "scrapeSlayerData": "ts-node tools/ScrapeSlayerData.ts",
+    "test": "jest",
+    "test:ci": "jest --ci --coverage",
+    "test:coverage": "jest --coverage",
+    "test:watch": "jest --watch",
+    "version": "npm run build && git add dist"
+  },
+  "dependencies": {
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^8.57.0",
+    "@tsconfig/recommended": "^1.0.11",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^18.19.130",
+    "@typescript-eslint/eslint-plugin": "^8.51.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "codecov": "^3.8.2",
+    "commitlint": "^17.8.1",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jest": "^27.9.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-sort-destructure-keys": "^1.6.0",
+    "eslint-plugin-sort-keys-fix": "^1.1.2",
+    "jest": "^29.7.0",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.1.2",
+    "ts-jest": "^29.4.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  }
+}

package/dist/errors/index.d.ts

@@ -1,97 +0,0 @@
-/**
- * Base error class for OSRS Tools
- * Contains additional context and helper methods
- */
-export declare class OsrsToolsError extends Error {
-    /** ISO timestamp when the error occurred */
-    readonly timestamp: string;
-    constructor(message: string);
-    /**
-     * Get error details in a structured format
-     */
-    toJSON(): {
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Error thrown when quest-related operations fail
- */
-export declare class QuestError extends OsrsToolsError {
-    readonly questName: string;
-    constructor(questName: string, message: string);
-    toJSON(): {
-        questName: string;
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Error thrown when skill-related operations fail
- */
-export declare class SkillError extends OsrsToolsError {
-    readonly skillName: string;
-    readonly value?: number;
-    constructor(skillName: string, message: string, value?: number);
-    toJSON(): {
-        skillName: string;
-        value: number | undefined;
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Error thrown when account-related operations fail
- */
-export declare class AccountError extends OsrsToolsError {
-    readonly accountName?: string;
-    constructor(message: string, accountName?: string);
-    toJSON(): {
-        accountName: string | undefined;
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Error thrown when API-related operations fail
- */
-export declare class ApiError extends OsrsToolsError {
-    readonly statusCode?: number;
-    readonly endpoint?: string;
-    constructor(message: string, statusCode?: number, endpoint?: string);
-    toJSON(): {
-        endpoint: string | undefined;
-        statusCode: number | undefined;
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-/**
- * Error thrown when validation fails
- */
-export declare class ValidationError extends OsrsToolsError {
-    readonly field: string;
-    readonly value: unknown;
-    readonly constraints: Record<string, unknown>;
-    constructor(field: string, value: unknown, message: string, constraints?: Record<string, unknown>);
-    toJSON(): {
-        constraints: Record<string, unknown>;
-        field: string;
-        value: unknown;
-        message: string;
-        name: string;
-        stack: string | undefined;
-        timestamp: string;
-    };
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,4CAA4C;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM;IAM3B;;OAEG;IACH,MAAM;;;;;;CAQP;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,cAAc;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAM9C,MAAM;;;;;;;CAMP;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,cAAc;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;gBAEZ,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAO9D,MAAM;;;;;;;;CAOP;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,cAAc;IAC9C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;IAMjD,MAAM;;;;;;;CAMP;AAED;;GAEG;AACH,qBAAa,QAAS,SAAQ,cAAc;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAOnE,MAAM;;;;;;;;CAOP;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,cAAc;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAG5C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM;IAS3C,MAAM;;;;;;;;;CAQP"}