playlist-data-engine 1.1.0

package/dist/core/config/sensorConfig.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Centralized configuration interface for all sensor modules
+ *
+ * This module provides type-safe configuration options for:
+ * - Environmental sensors (geolocation, weather, motion)
+ * - Gaming platform sensors (Steam)
+ * - XP modifier calculation
+ * - Caching and retry behavior
+ *
+ * Configuration can be provided via constructor parameters or loaded from environment variables.
+ */
+import type { SensorRetryConfig } from '../types/Environmental.js';
+/**
+ * Cache configuration for sensor data
+ */
+export interface CacheConfig {
+    /** Time-to-live for cached data in milliseconds (default: varies by sensor) */
+    ttlMs: number;
+    /** Enable/disable localStorage persistence for browser environments (default: true) */
+    useLocalStorage: boolean;
+}
+/**
+ * Geolocation sensor configuration
+ */
+export interface GeolocationSensorConfig {
+    /** Cache TTL in milliseconds (default: 5 minutes) */
+    cacheTTL?: number;
+    /** Enable localStorage persistence (default: true) */
+    useLocalStorage?: boolean;
+    /** High accuracy mode for GPS (default: true) */
+    enableHighAccuracy?: boolean;
+    /** GPS timeout in milliseconds (default: 5000) */
+    timeout?: number;
+}
+/**
+ * Weather API configuration
+ */
+export interface WeatherSensorConfig {
+    /** OpenWeatherMap API key (can be loaded from WEATHER_API_KEY env var) */
+    apiKey?: string;
+    /** Current weather cache TTL in milliseconds (default: 12 minutes) */
+    cacheTTL?: number;
+    /** Forecast cache TTL in milliseconds (default: 60 minutes) */
+    forecastCacheTTL?: number;
+    /** Enable localStorage persistence (default: true) */
+    useLocalStorage?: boolean;
+}
+/**
+ * Gaming platform sensor configuration
+ */
+export interface GamingSensorConfig {
+    /** Steam configuration */
+    steam?: {
+        /** Steam API key (can be loaded from STEAM_API_KEY env var) */
+        apiKey?: string;
+        /** Steam user ID (64-bit ID) */
+        steamId?: string;
+        /** Polling interval in milliseconds (default: 60000 = 1 minute) */
+        pollInterval?: number;
+    };
+    /** Game metadata cache expiry in milliseconds (default: 24 hours) */
+    metadataCacheExpiry?: number;
+    /** Maximum backoff delay in milliseconds for polling errors (default: 10 minutes) */
+    maxBackoffMs?: number;
+    /** XP modifier configuration (overrides for gaming-specific bonuses) */
+    xpModifier?: Partial<XPModifierConfig>;
+}
+/**
+ * XP modifier calculation configuration
+ */
+export interface XPModifierConfig {
+    /** Maximum XP modifier multiplier (default: 3.0) */
+    maxModifier: number;
+    /** Maximum gaming XP modifier multiplier (default: 1.75) */
+    maxGamingModifier: number;
+    /** Motion-based bonus: running (default: 0.5 = +50%) */
+    runningBonus: number;
+    /** Motion-based bonus: walking (default: 0.2 = +20%) */
+    walkingBonus: number;
+    /** Weather-based bonus: rain/storm (default: 0.4 = +40%) */
+    stormBonus: number;
+    /** Weather-based bonus: snow (default: 0.3 = +30%) */
+    snowBonus: number;
+    /** Time-based bonus: night (default: 0.25 = +25%) */
+    nightBonus: number;
+    /** Altitude-based bonus threshold in meters (default: 1000) */
+    altitudeThreshold: number;
+    /** Altitude-based bonus amount (default: 0.3 = +30%) */
+    altitudeBonus: number;
+    /** Gaming base bonus (default: 0.25 = +25%) */
+    gamingBaseBonus: number;
+    /** Gaming RPG genre bonus (default: 0.2 = +20%) */
+    gamingRPGBonus: number;
+    /** Gaming multiplayer bonus (default: 0.15 = +15%) */
+    gamingMultiplayerBonus: number;
+}
+/**
+ * Retry configuration for sensor operations
+ */
+export interface RetryConfig extends SensorRetryConfig {
+    /** Enable/disable retry logic entirely (default: true) */
+    enabled: boolean;
+}
+/**
+ * Complete sensor configuration interface
+ */
+export interface SensorConfig {
+    /** Geolocation sensor configuration */
+    geolocation: Partial<GeolocationSensorConfig>;
+    /** Weather sensor configuration */
+    weather: Partial<WeatherSensorConfig>;
+    /** Gaming platform configuration */
+    gaming: Partial<GamingSensorConfig>;
+    /** XP modifier configuration */
+    xpModifier: Partial<XPModifierConfig>;
+    /** Retry configuration */
+    retry: Partial<RetryConfig>;
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_SENSOR_CONFIG: Required<SensorConfig>;
+/**
+ * Load configuration from environment variables
+ * @returns Partial configuration loaded from environment
+ */
+export declare function loadConfigFromEnv(): Partial<SensorConfig>;
+/**
+ * Merge user config with defaults and environment variables
+ * @param userConfig User-provided configuration
+ * @returns Merged configuration with defaults applied
+ */
+export declare function mergeConfig(userConfig?: Partial<SensorConfig>): Required<SensorConfig>;
+//# sourceMappingURL=sensorConfig.d.ts.map

package/dist/core/config/sensorConfig.d.ts.map

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

package/dist/core/equipment/BoxOpener.d.ts

@@ -0,0 +1,175 @@
+/**
+ * BoxOpener - Handles opening box items and generating their contents
+ *
+ * Supports both guaranteed containers (like Explorer's Pack) and
+ * probability-based loot boxes.
+ *
+ * Features:
+ * - Weighted random selection from drop pools
+ * - Quantity support for bulk items (e.g., 10 torches, 20 arrows)
+ * - Gold drops alongside or instead of items
+ * - Nested boxes are added unopened (not recursively opened)
+ * - Deterministic results via SeededRNG
+ */
+import type { Equipment } from '../../utils/constants.js';
+import type { BoxOpenError, BoxOpenRequirement, BoxOpenResult, EnhancedInventoryItem } from '../types/Equipment.js';
+import { SeededRNG } from '../../utils/random.js';
+/**
+ * BoxOpener class for opening box-type equipment items
+ *
+ * @example
+ * ```typescript
+ * import { BoxOpener, SeededRNG } from 'playlist-data-engine';
+ *
+ * const rng = new SeededRNG('test-seed');
+ * const result = BoxOpener.openBox(explorersPack, rng);
+ * console.log(result.items); // Generated items
+ * console.log(result.gold);   // Gold amount
+ * ```
+ */
+export declare class BoxOpener {
+    /**
+     * Open a box and generate its contents
+     *
+     * @param box - The box equipment to open (must have boxContents)
+     * @param rng - SeededRNG for deterministic results
+     * @param inventory - Optional character inventory for requirement checking.
+     *                     If not provided, requirements are skipped (backward compatible).
+     * @returns BoxOpenResult with items, gold, and consumed items if requirements were met
+     *
+     * @example
+     * ```typescript
+     * const rng = new SeededRNG('deterministic-seed');
+     * const result = BoxOpener.openBox(goblinChest, rng);
+     * // result.items - array of generated items
+     * // result.gold - total gold from drops
+     * // result.consumeBox - whether box should be consumed
+     *
+     * // With inventory (requirement checking enabled)
+     * const inventory = [{ name: 'Iron Key', quantity: 1, equipped: false }];
+     * const result = BoxOpener.openBox(lockedChest, rng, inventory);
+     * if (result.success) {
+     *     console.log('Consumed:', result.consumedItems);
+     * } else {
+     *     console.log('Cannot open:', result.error?.message);
+     * }
+     * ```
+     */
+    static openBox(box: Equipment, rng: SeededRNG, inventory?: EnhancedInventoryItem[]): BoxOpenResult;
+    /**
+     * Select one item from a weighted pool using SeededRNG
+     *
+     * @param pool - Array of pool entries with weights
+     * @param rng - SeededRNG for deterministic selection
+     * @returns Selected pool entry, or undefined if pool is empty
+     */
+    private static selectFromPool;
+    /**
+     * Get equipment data from the registry (defaults + custom)
+     *
+     * @param itemName - Name of the equipment to look up
+     * @returns Equipment data or undefined if not found
+     */
+    private static getEquipmentData;
+    /**
+     * Check if an equipment item is a box type
+     *
+     * @param equipment - Equipment to check
+     * @returns True if equipment is a box type
+     */
+    static isBox(equipment: Equipment): boolean;
+    /**
+     * Check if box requirements are met
+     *
+     * Validates that the character's inventory contains all required items
+     * in sufficient quantities to open the box.
+     *
+     * @param box - The box to check requirements for
+     * @param inventory - Character's items inventory
+     * @returns null if all requirements are met, BoxOpenError if not
+     *
+     * @example
+     * ```typescript
+     * const box = { name: 'Locked Chest', boxContents: { openRequirements: [{ itemName: 'Iron Key' }] } };
+     * const inventory = [{ name: 'Iron Key', quantity: 1, equipped: false }];
+     *
+     * const error = BoxOpener.checkRequirements(box, inventory);
+     * if (error) {
+     *     console.log(`Cannot open: ${error.message}`);
+     * }
+     * ```
+     */
+    static checkRequirements(box: Equipment, inventory: EnhancedInventoryItem[]): BoxOpenError | null;
+    /**
+     * Check if a box can be opened with given inventory
+     *
+     * Simple boolean check useful for UI purposes (showing lock icons, etc).
+     *
+     * @param box - The box to check
+     * @param inventory - Character's items inventory
+     * @returns true if box can be opened, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const box = { name: 'Locked Chest', boxContents: { openRequirements: [{ itemName: 'Iron Key' }] } };
+     * const inventory = [{ name: 'Iron Key', quantity: 1, equipped: false }];
+     *
+     * if (BoxOpener.canOpen(box, inventory)) {
+     *     console.log('You can open this chest!');
+     * }
+     * ```
+     */
+    static canOpen(box: Equipment, inventory: EnhancedInventoryItem[]): boolean;
+    /**
+     * Get human-readable description of box requirements
+     *
+     * Returns a formatted string describing what items are needed to open the box,
+     * useful for UI displays or tooltips.
+     *
+     * @param box - The box equipment to get requirements description for
+     * @returns Formatted description string like "Requires: Iron Key" or
+     *          "Requires: Iron Key, 100 Gold Coins", or null if no requirements
+     *
+     * @example
+     * ```typescript
+     * const lockedChest = { boxContents: { openRequirements: [{ itemName: 'Iron Key' }] } };
+     * console.log(BoxOpener.getRequirementsDescription(lockedChest));
+     * // "Requires: Iron Key"
+     *
+     * const multiReq = { boxContents: { openRequirements: [
+     *     { itemName: 'Golden Key' },
+     *     { itemName: 'Gold Coin', quantity: 200 }
+     * ]}};
+     * console.log(BoxOpener.getRequirementsDescription(multiReq));
+     * // "Requires: Golden Key, 200 Gold Coins"
+     * ```
+     */
+    static getRequirementsDescription(box: Equipment): string | null;
+    /**
+     * Preview what a box could contain without actually opening it
+     *
+     * Returns all possible items that could drop from the box,
+     * useful for UI displays or tooltips.
+     *
+     * @param box - The box equipment to preview
+     * @returns Object with possible items, gold range, total drops, and any opening requirements
+     *
+     * @example
+     * ```typescript
+     * const preview = BoxOpener.previewContents(lockedChest);
+     * console.log('Possible items:', preview.possibleItems);
+     * console.log('Requires:', preview.openRequirements);
+     * // [{ itemName: 'Iron Key' }]
+     * ```
+     */
+    static previewContents(box: Equipment): {
+        possibleItems: string[];
+        possibleGold: {
+            min: number;
+            max: number;
+        };
+        totalDrops: number;
+        openRequirements?: BoxOpenRequirement[];
+    };
+}
+//# sourceMappingURL=BoxOpener.d.ts.map

package/dist/core/equipment/BoxOpener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoxOpener.d.ts","sourceRoot":"","sources":["../../../src/core/equipment/BoxOpener.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,KAAK,EAA4B,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,qBAAqB,EAAqB,MAAM,uBAAuB,CAAC;AACjK,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD;;;;;;;;;;;;GAYG;AACH,qBAAa,SAAS;IAClB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,OAAO,CACV,GAAG,EAAE,SAAS,EACd,GAAG,EAAE,SAAS,EACd,SAAS,CAAC,EAAE,qBAAqB,EAAE,GACpC,aAAa;IAgGhB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAc7B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO;IAI3C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,iBAAiB,CACpB,GAAG,EAAE,SAAS,EACd,SAAS,EAAE,qBAAqB,EAAE,GACnC,YAAY,GAAG,IAAI;IAsCtB;;;;;;;;;;;;;;;;;;OAkBG;IACH,MAAM,CAAC,OAAO,CACV,GAAG,EAAE,SAAS,EACd,SAAS,EAAE,qBAAqB,EAAE,GACnC,OAAO;IAUV;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,MAAM,CAAC,0BAA0B,CAAC,GAAG,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI;IAqBhE;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,eAAe,CAAC,GAAG,EAAE,SAAS,GAAG;QACpC,aAAa,EAAE,MAAM,EAAE,CAAC;QACxB,YAAY,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,GAAG,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3C,UAAU,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAC;KAC3C;CA2CJ"}

package/dist/core/equipment/EquipmentEffectApplier.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Equipment Effect Applier
+ *
+ * Applies and removes equipment effects to/from characters during equip/unequip.
+ * Handles stat bonuses, skill proficiencies, ability unlocks, passive modifiers,
+ * equipment-granted features, skills, and spells.
+ * Integrates with FeatureEffectApplier.
+ */
+import type { CharacterSheet } from '../types/Character.js';
+import type { EnhancedEquipment, EquipmentProperty, EffectApplicationResult } from '../types/Equipment.js';
+/**
+ * EquipmentEffectApplier - Applies and removes equipment effects
+ *
+ * This class handles:
+ * - Applying equipment properties when equipping
+ * - Removing equipment properties when unequipping
+ * - Managing equipment-granted features, skills, and spells
+ * - Tracking equipment effects separately from feature effects for proper removal
+ *
+ * STACKING: All equipment effects stack by default. Multiple items with the same
+ * effect will have their effects combine (e.g., two +1 STR items = +2 STR total).
+ */
+export declare class EquipmentEffectApplier {
+    /**
+     * Apply all effects from equipping an item
+     *
+     * @param character - The character to apply effects to
+     * @param equipment - The equipment being equipped
+     * @param instanceId - Optional instance ID for per-instance tracking
+     * @returns Result of the effect application
+     */
+    static equipItem(character: CharacterSheet, equipment: EnhancedEquipment, instanceId?: string): EffectApplicationResult;
+    /**
+     * Remove all effects from unequipping an item
+     *
+     * @param character - The character to remove effects from
+     * @param equipmentName - Name of the equipment being unequipped
+     * @param instanceId - Optional instance ID for per-instance tracking
+     * @returns Result of the effect removal
+     */
+    static unequipItem(character: CharacterSheet, equipmentName: string, instanceId?: string): EffectApplicationResult;
+    /**
+     * Re-apply all equipment effects (for updates/level-ups)
+     *
+     * @param character - The character to reapply effects to
+     * @returns Result of the effect reapplication
+     */
+    static reapplyEquipmentEffects(character: CharacterSheet): EffectApplicationResult;
+    /**
+     * Get all active equipment effects
+     *
+     * @param character - The character to get effects from
+     * @returns Array of all active equipment properties
+     */
+    static getActiveEffects(character: CharacterSheet): EquipmentProperty[];
+    /**
+     * Apply a single equipment property
+     *
+     * For property types that match FeatureEffect types (stat_bonus, skill_proficiency,
+     * ability_unlock, passive_modifier), we apply them using dedicated methods for consistency.
+     */
+    /**
+     * Evaluate an armor AC formula string against a character's DEX modifier.
+     *
+     * Supported patterns:
+     * - "16"              → flat AC (heavy armor, no DEX)
+     * - "11 + DEX"        → base + full DEX (light armor)
+     * - "14 + min(DEX, 2)"→ base + capped DEX (medium armor)
+     *
+     * @param formula - The AC formula string from equipment properties
+     * @param dexMod - The character's DEX modifier
+     * @returns Computed armor class
+     */
+    static evaluateACFormula(formula: string, dexMod: number): number;
+    private static applyProperty;
+    /**
+     * Apply an equipment property using dedicated methods.
+     *
+     * This ensures equipment effects that match feature effect types
+     * (stat_bonus, skill_proficiency, ability_unlock, passive_modifier)
+     * are applied consistently.
+     */
+    private static applyPropertyViaFeatureEffectApplier;
+    /**
+     * Apply a stat bonus property
+     */
+    private static applyStatBonus;
+    /**
+     * Apply a skill proficiency property
+     *
+     * Uses shared utility with proficiency hierarchy (none < proficient < expertise)
+     */
+    private static applySkillProficiency;
+    /**
+     * Apply an ability unlock property
+     */
+    private static applyAbilityUnlock;
+    /**
+     * Apply a passive modifier property
+     */
+    private static applyPassiveModifier;
+    /**
+     * Track a special property for game logic reference
+     */
+    private static trackSpecialProperty;
+    /**
+     * Track a damage bonus for game logic reference
+     */
+    private static trackDamageBonus;
+    /**
+     * Remove equipment properties from character
+     */
+    private static removeProperties;
+    /**
+     * Remove a stat bonus
+     */
+    private static removeStatBonus;
+    /**
+     * Remove a skill proficiency
+     */
+    private static removeSkillProficiency;
+    /**
+     * Remove a passive modifier
+     */
+    private static removePassiveModifier;
+    /**
+     * Apply equipment-granted features
+     */
+    private static applyEquipmentFeatures;
+    /**
+     * Apply equipment-granted skills
+     */
+    private static applyEquipmentSkills;
+    /**
+     * Add spells to character
+     */
+    private static addSpellsToCharacter;
+    /**
+     * Remove spells from character
+     */
+    private static removeSpellsFromCharacter;
+    /**
+     * Add a feature to character's class features list
+     */
+    private static addFeatureToCharacter;
+    /**
+     * Add a skill to character
+     *
+     * Uses shared utility with proficiency hierarchy (none < proficient < expertise)
+     */
+    private static addSkillToCharacter;
+    /**
+     * Remove equipment-granted features
+     */
+    private static removeEquipmentFeatures;
+    /**
+     * Remove equipment-granted skills
+     */
+    private static removeEquipmentSkills;
+    /**
+     * Check if a property condition is met
+     */
+    private static checkCondition;
+    /**
+     * Find an equipment effect entry
+     */
+    private static findEquipmentEffect;
+    /**
+     * Validate stat requirements before equipping an item
+     *
+     * Checks all stat_requirement properties and returns errors for any
+     * requirements that are not met. This is called BEFORE applying effects,
+     * so items that don't meet requirements cannot be equipped.
+     *
+     * @param character - The character equipping the item
+     * @param equipment - The equipment being equipped
+     * @param properties - The properties to validate
+     * @returns Array of error messages (empty if all requirements met)
+     */
+    private static validateRequirements;
+    /**
+     * Track a stat requirement for reference
+     *
+     * Stat requirements are validated before equipping, but we track them
+     * in equipment_effects so game logic can reference them if needed.
+     */
+    private static trackStatRequirement;
+}
+//# sourceMappingURL=EquipmentEffectApplier.d.ts.map

package/dist/core/equipment/EquipmentEffectApplier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EquipmentEffectApplier.d.ts","sourceRoot":"","sources":["../../../src/core/equipment/EquipmentEffectApplier.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EACR,iBAAiB,EACjB,iBAAiB,EAIjB,uBAAuB,EAC1B,MAAM,uBAAuB,CAAC;AAM/B;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAsB;IAC/B;;;;;;;OAOG;IACH,MAAM,CAAC,SAAS,CACZ,SAAS,EAAE,cAAc,EACzB,SAAS,EAAE,iBAAiB,EAC5B,UAAU,CAAC,EAAE,MAAM,GACpB,uBAAuB;IA8F1B;;;;;;;OAOG;IACH,MAAM,CAAC,WAAW,CACd,SAAS,EAAE,cAAc,EACzB,aAAa,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GACpB,uBAAuB;IAwD1B;;;;;OAKG;IACH,MAAM,CAAC,uBAAuB,CAC1B,SAAS,EAAE,cAAc,GAC1B,uBAAuB;IA+E1B;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CACnB,SAAS,EAAE,cAAc,GAC1B,iBAAiB,EAAE;IAYtB;;;;;OAKG;IACH;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM;IA0BjE,OAAO,CAAC,MAAM,CAAC,aAAa;IAmC5B;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,oCAAoC;IAsBnD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IAiB7B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAUpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAWjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAuCnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAanC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAwB/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAY9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IASrC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAsBpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiDrC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAsBnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAyBnC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,yBAAyB;IAqBxC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAUpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IASlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IAoBtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAWpC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,cAAc;IA4B7B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAWlC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;IA4BnC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,oBAAoB;CAYtC"}