universal-agent-memory 0.7.3 → 0.8.0

package/dist/utils/fetch-with-retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-with-retry.js","sourceRoot":"","sources":["../../src/utils/fetch-with-retry.ts"],"names":[],"mappings":"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"}

package/dist/utils/order-processor-refactored.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Order Processing - Refactored using SOLID Principles
+ *
+ * This implementation follows:
+ * - Single Responsibility Principle: Each strategy handles one order type
+ * - Open/Closed Principle: New order types can be added without modifying existing code
+ * - Liskov Substitution Principle: All strategies are interchangeable
+ * - Interface Segregation Principle: Focused interfaces for specific behaviors
+ * - Dependency Inversion Principle: High-level module depends on abstractions
+ */
+/**
+ * Represents the possible statuses an order can have
+ */
+export type OrderStatus = 'pending' | 'delivered' | 'shipped' | 'active' | 'cancelled';
+/**
+ * Represents the supported order types
+ */
+export type OrderType = 'digital' | 'physical' | 'subscription';
+/**
+ * Base order interface with common properties
+ */
+export interface Order {
+    readonly id: string;
+    readonly type: OrderType;
+    status: OrderStatus;
+}
+/**
+ * Digital order with download-specific properties
+ */
+export interface DigitalOrder extends Order {
+    readonly type: 'digital';
+    readonly downloadUrl?: string;
+}
+/**
+ * Physical order with shipping-specific properties
+ */
+export interface PhysicalOrder extends Order {
+    readonly type: 'physical';
+    readonly shippingAddress?: string;
+}
+/**
+ * Subscription order with subscription-specific properties
+ */
+export interface SubscriptionOrder extends Order {
+    readonly type: 'subscription';
+    readonly subscriptionPlan?: string;
+}
+/**
+ * Union type for all order types
+ */
+export type AnyOrder = DigitalOrder | PhysicalOrder | SubscriptionOrder;
+/**
+ * Result of processing an order
+ */
+export interface ProcessingResult {
+    readonly success: boolean;
+    readonly order: AnyOrder;
+    readonly message: string;
+}
+/**
+ * Logger interface for dependency injection
+ */
+export interface Logger {
+    log(message: string): void;
+}
+/**
+ * Strategy interface for processing orders (Open/Closed Principle)
+ */
+export interface OrderProcessingStrategy {
+    /**
+     * Check if this strategy can handle the given order type
+     */
+    canHandle(orderType: OrderType): boolean;
+    /**
+     * Process the order and return the result
+     */
+    process(order: AnyOrder, logger: Logger): ProcessingResult;
+}
+/**
+ * Strategy for processing digital orders
+ */
+export declare class DigitalOrderStrategy implements OrderProcessingStrategy {
+    canHandle(orderType: OrderType): boolean;
+    process(order: AnyOrder, logger: Logger): ProcessingResult;
+}
+/**
+ * Strategy for processing physical orders
+ */
+export declare class PhysicalOrderStrategy implements OrderProcessingStrategy {
+    canHandle(orderType: OrderType): boolean;
+    process(order: AnyOrder, logger: Logger): ProcessingResult;
+}
+/**
+ * Strategy for processing subscription orders
+ */
+export declare class SubscriptionOrderStrategy implements OrderProcessingStrategy {
+    canHandle(orderType: OrderType): boolean;
+    process(order: AnyOrder, logger: Logger): ProcessingResult;
+}
+/**
+ * Console-based logger implementation
+ */
+export declare class ConsoleLogger implements Logger {
+    log(message: string): void;
+}
+/**
+ * Main order processor that uses strategies to handle different order types
+ */
+export declare class OrderProcessor {
+    private readonly strategies;
+    private readonly logger;
+    constructor(strategies: OrderProcessingStrategy[], logger: Logger);
+    /**
+     * Process an order using the appropriate strategy
+     */
+    processOrder(order: AnyOrder): ProcessingResult;
+}
+/**
+ * Factory function to create a fully configured OrderProcessor
+ */
+export declare function createOrderProcessor(logger?: Logger): OrderProcessor;
+/**
+ * Example usage demonstrating the refactored code
+ */
+export declare function exampleUsage(): void;
+//# sourceMappingURL=order-processor-refactored.d.ts.map

package/dist/utils/order-processor-refactored.d.ts.map

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

package/dist/utils/order-processor-refactored.js

@@ -0,0 +1,165 @@
+/**
+ * Order Processing - Refactored using SOLID Principles
+ *
+ * This implementation follows:
+ * - Single Responsibility Principle: Each strategy handles one order type
+ * - Open/Closed Principle: New order types can be added without modifying existing code
+ * - Liskov Substitution Principle: All strategies are interchangeable
+ * - Interface Segregation Principle: Focused interfaces for specific behaviors
+ * - Dependency Inversion Principle: High-level module depends on abstractions
+ */
+// ============================================================================
+// Strategy Implementations (Single Responsibility Principle)
+// ============================================================================
+/**
+ * Strategy for processing digital orders
+ */
+export class DigitalOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'digital';
+    }
+    process(order, logger) {
+        logger.log('Sending email with download link');
+        const processedOrder = {
+            ...order,
+            status: 'delivered',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Digital order delivered via email',
+        };
+    }
+}
+/**
+ * Strategy for processing physical orders
+ */
+export class PhysicalOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'physical';
+    }
+    process(order, logger) {
+        logger.log('Creating shipping label');
+        const processedOrder = {
+            ...order,
+            status: 'shipped',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Physical order shipped',
+        };
+    }
+}
+/**
+ * Strategy for processing subscription orders
+ */
+export class SubscriptionOrderStrategy {
+    canHandle(orderType) {
+        return orderType === 'subscription';
+    }
+    process(order, logger) {
+        logger.log('Activating subscription');
+        const processedOrder = {
+            ...order,
+            status: 'active',
+        };
+        return {
+            success: true,
+            order: processedOrder,
+            message: 'Subscription activated',
+        };
+    }
+}
+// ============================================================================
+// Default Logger Implementation
+// ============================================================================
+/**
+ * Console-based logger implementation
+ */
+export class ConsoleLogger {
+    log(message) {
+        console.log(message);
+    }
+}
+// ============================================================================
+// Order Processor (Dependency Inversion Principle)
+// ============================================================================
+/**
+ * Main order processor that uses strategies to handle different order types
+ */
+export class OrderProcessor {
+    strategies;
+    logger;
+    constructor(strategies, logger) {
+        this.strategies = strategies;
+        this.logger = logger;
+    }
+    /**
+     * Process an order using the appropriate strategy
+     */
+    processOrder(order) {
+        const strategy = this.strategies.find((s) => s.canHandle(order.type));
+        if (!strategy) {
+            return {
+                success: false,
+                order,
+                message: `No strategy found for order type: ${order.type}`,
+            };
+        }
+        const result = strategy.process(order, this.logger);
+        this.logger.log(`Order processed: ${order.id}`);
+        return result;
+    }
+}
+// ============================================================================
+// Factory for Easy Setup
+// ============================================================================
+/**
+ * Factory function to create a fully configured OrderProcessor
+ */
+export function createOrderProcessor(logger) {
+    const strategies = [
+        new DigitalOrderStrategy(),
+        new PhysicalOrderStrategy(),
+        new SubscriptionOrderStrategy(),
+    ];
+    return new OrderProcessor(strategies, logger ?? new ConsoleLogger());
+}
+// ============================================================================
+// Usage Example
+// ============================================================================
+/**
+ * Example usage demonstrating the refactored code
+ */
+export function exampleUsage() {
+    const processor = createOrderProcessor();
+    const digitalOrder = {
+        id: 'order-001',
+        type: 'digital',
+        status: 'pending',
+        downloadUrl: 'https://example.com/download/abc',
+    };
+    const physicalOrder = {
+        id: 'order-002',
+        type: 'physical',
+        status: 'pending',
+        shippingAddress: '123 Main St, City, Country',
+    };
+    const subscriptionOrder = {
+        id: 'order-003',
+        type: 'subscription',
+        status: 'pending',
+        subscriptionPlan: 'premium-monthly',
+    };
+    console.log('Processing digital order:');
+    const digitalResult = processor.processOrder(digitalOrder);
+    console.log('Result:', digitalResult);
+    console.log('\nProcessing physical order:');
+    const physicalResult = processor.processOrder(physicalOrder);
+    console.log('Result:', physicalResult);
+    console.log('\nProcessing subscription order:');
+    const subscriptionResult = processor.processOrder(subscriptionOrder);
+    console.log('Result:', subscriptionResult);
+}
+//# sourceMappingURL=order-processor-refactored.js.map

package/dist/utils/order-processor-refactored.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-refactored.js","sourceRoot":"","sources":["../../src/utils/order-processor-refactored.ts"],"names":[],"mappings":"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"}

package/dist/utils/order-processor-strategy.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Strategy Pattern Implementation for Order Processing
+ *
+ * The Strategy pattern allows defining a family of algorithms, encapsulating each one,
+ * and making them interchangeable. This refactoring replaces conditional logic with
+ * polymorphic behavior.
+ */
+type OrderType = 'digital' | 'physical' | 'subscription';
+interface Order {
+    type: OrderType;
+    status?: string;
+    [key: string]: any;
+}
+/**
+ * OrderProcessingStrategy defines the contract for all order processing strategies.
+ * Each concrete strategy implements the process method according to its specific logic.
+ */
+interface OrderProcessingStrategy {
+    process(order: Order): Order;
+}
+/**
+ * DigitalOrderStrategy handles digital product orders.
+ * Digital orders are immediately delivered upon processing.
+ */
+declare class DigitalOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+}
+/**
+ * PhysicalOrderStrategy handles physical product orders.
+ * Physical orders require shipping and physical delivery.
+ */
+declare class PhysicalOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+    private estimateDelivery;
+}
+/**
+ * SubscriptionOrderStrategy handles subscription orders.
+ * Subscriptions activate immediately and require ongoing billing.
+ */
+declare class SubscriptionOrderStrategy implements OrderProcessingStrategy {
+    process(order: Order): Order;
+    private calculateNextBilling;
+}
+/**
+ * OrderProcessor acts as the context that uses strategies to process orders.
+ * It maintains a strategy registry and delegates order processing to the appropriate strategy.
+ */
+declare class OrderProcessor {
+    private strategies;
+    constructor();
+    /**
+     * Process an order using the appropriate strategy based on its type.
+     * @param order The order to process
+     * @returns The processed order with status and additional metadata
+     * @throws Error if no strategy is found for the order type
+     */
+    processOrder(order: Order): Order;
+    /**
+     * Register a custom strategy for a specific order type.
+     * This allows extending the processor with new order types at runtime.
+     * @param orderType The order type this strategy handles
+     * @param strategy The strategy to register
+     */
+    registerStrategy(orderType: string, strategy: OrderProcessingStrategy): void;
+    /**
+     * Get all registered order types.
+     * @returns Array of supported order types
+     */
+    getSupportedOrderTypes(): OrderType[];
+}
+export { Order, OrderType, OrderProcessingStrategy, DigitalOrderStrategy, PhysicalOrderStrategy, SubscriptionOrderStrategy, OrderProcessor };
+//# sourceMappingURL=order-processor-strategy.d.ts.map

package/dist/utils/order-processor-strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-strategy.d.ts","sourceRoot":"","sources":["../../src/utils/order-processor-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,KAAK,SAAS,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAGzD,UAAU,KAAK;IACb,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAMD;;;GAGG;AACH,UAAU,uBAAuB;IAC/B,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;CAC9B;AAMD;;;GAGG;AACH,cAAM,oBAAqB,YAAW,uBAAuB;IAC3D,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;CAQ7B;AAED;;;GAGG;AACH,cAAM,qBAAsB,YAAW,uBAAuB;IAC5D,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAU5B,OAAO,CAAC,gBAAgB;CAKzB;AAED;;;GAGG;AACH,cAAM,yBAA0B,YAAW,uBAAuB;IAChE,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAW5B,OAAO,CAAC,oBAAoB;CAK7B;AAMD;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,UAAU,CAA0C;;IAW5D;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAUjC;;;;;OAKG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,GAAG,IAAI;IAI5E;;;OAGG;IACH,sBAAsB,IAAI,SAAS,EAAE;CAGtC;AAgDD,OAAO,EACL,KAAK,EACL,SAAS,EACT,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,cAAc,EACf,CAAC"}

package/dist/utils/order-processor-strategy.js

@@ -0,0 +1,158 @@
+/**
+ * Strategy Pattern Implementation for Order Processing
+ *
+ * The Strategy pattern allows defining a family of algorithms, encapsulating each one,
+ * and making them interchangeable. This refactoring replaces conditional logic with
+ * polymorphic behavior.
+ */
+// ============================================================================
+// CONCRETE STRATEGIES
+// ============================================================================
+/**
+ * DigitalOrderStrategy handles digital product orders.
+ * Digital orders are immediately delivered upon processing.
+ */
+class DigitalOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'delivered',
+            deliveryMethod: 'digital',
+            deliveryTimestamp: new Date().toISOString()
+        };
+    }
+}
+/**
+ * PhysicalOrderStrategy handles physical product orders.
+ * Physical orders require shipping and physical delivery.
+ */
+class PhysicalOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'shipped',
+            deliveryMethod: 'physical',
+            shippingDate: new Date().toISOString(),
+            estimatedDelivery: this.estimateDelivery()
+        };
+    }
+    estimateDelivery() {
+        const date = new Date();
+        date.setDate(date.getDate() + 5); // 5 business days
+        return date.toISOString();
+    }
+}
+/**
+ * SubscriptionOrderStrategy handles subscription orders.
+ * Subscriptions activate immediately and require ongoing billing.
+ */
+class SubscriptionOrderStrategy {
+    process(order) {
+        return {
+            ...order,
+            status: 'active',
+            subscriptionType: 'recurring',
+            billingCycle: 'monthly',
+            activationDate: new Date().toISOString(),
+            nextBilling: this.calculateNextBilling()
+        };
+    }
+    calculateNextBilling() {
+        const date = new Date();
+        date.setMonth(date.getMonth() + 1);
+        return date.toISOString();
+    }
+}
+// ============================================================================
+// CONTEXT (ORDER PROCESSOR)
+// ============================================================================
+/**
+ * OrderProcessor acts as the context that uses strategies to process orders.
+ * It maintains a strategy registry and delegates order processing to the appropriate strategy.
+ */
+class OrderProcessor {
+    strategies;
+    constructor() {
+        // Initialize the strategy registry
+        this.strategies = new Map([
+            ['digital', new DigitalOrderStrategy()],
+            ['physical', new PhysicalOrderStrategy()],
+            ['subscription', new SubscriptionOrderStrategy()]
+        ]);
+    }
+    /**
+     * Process an order using the appropriate strategy based on its type.
+     * @param order The order to process
+     * @returns The processed order with status and additional metadata
+     * @throws Error if no strategy is found for the order type
+     */
+    processOrder(order) {
+        const strategy = this.strategies.get(order.type);
+        if (!strategy) {
+            throw new Error(`No processing strategy found for order type: ${order.type}`);
+        }
+        return strategy.process(order);
+    }
+    /**
+     * Register a custom strategy for a specific order type.
+     * This allows extending the processor with new order types at runtime.
+     * @param orderType The order type this strategy handles
+     * @param strategy The strategy to register
+     */
+    registerStrategy(orderType, strategy) {
+        this.strategies.set(orderType, strategy);
+    }
+    /**
+     * Get all registered order types.
+     * @returns Array of supported order types
+     */
+    getSupportedOrderTypes() {
+        return Array.from(this.strategies.keys());
+    }
+}
+// ============================================================================
+// USAGE EXAMPLE
+// ============================================================================
+/**
+ * Example usage demonstrating the Strategy pattern in action.
+ */
+function demonstrateOrderProcessing() {
+    const processor = new OrderProcessor();
+    // Example orders
+    const digitalOrder = {
+        type: 'digital',
+        id: 'DIG-001',
+        product: 'Premium Software License',
+        price: 99.99
+    };
+    const physicalOrder = {
+        type: 'physical',
+        id: 'PHY-001',
+        product: 'Office Chair',
+        price: 249.99,
+        shippingAddress: '123 Main St, City, State'
+    };
+    const subscriptionOrder = {
+        type: 'subscription',
+        id: 'SUB-001',
+        product: 'Cloud Storage Pro',
+        price: 19.99
+    };
+    // Process orders
+    console.log('Processing Digital Order:');
+    console.log(JSON.stringify(processor.processOrder(digitalOrder), null, 2));
+    console.log('\nProcessing Physical Order:');
+    console.log(JSON.stringify(processor.processOrder(physicalOrder), null, 2));
+    console.log('\nProcessing Subscription Order:');
+    console.log(JSON.stringify(processor.processOrder(subscriptionOrder), null, 2));
+    // Show supported order types
+    console.log('\nSupported Order Types:', processor.getSupportedOrderTypes());
+}
+// Export for use in other modules
+export { DigitalOrderStrategy, PhysicalOrderStrategy, SubscriptionOrderStrategy, OrderProcessor };
+// Run demo if executed directly
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+    demonstrateOrderProcessing();
+}
+//# sourceMappingURL=order-processor-strategy.js.map

package/dist/utils/order-processor-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-processor-strategy.js","sourceRoot":"","sources":["../../src/utils/order-processor-strategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAwBH,+EAA+E;AAC/E,sBAAsB;AACtB,+EAA+E;AAE/E;;;GAGG;AACH,MAAM,oBAAoB;IACxB,OAAO,CAAC,KAAY;QAClB,OAAO;YACL,GAAG,KAAK;YACR,MAAM,EAAE,WAAW;YACnB,cAAc,EAAE,SAAS;YACzB,iBAAiB,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SAC5C,CAAC;IACJ,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,qBAAqB;IACzB,OAAO,CAAC,KAAY;QAClB,OAAO;YACL,GAAG,KAAK;YACR,MAAM,EAAE,SAAS;YACjB,cAAc,EAAE,UAAU;YAC1B,YAAY,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACtC,iBAAiB,EAAE,IAAI,CAAC,gBAAgB,EAAE;SAC3C,CAAC;IACJ,CAAC;IAEO,gBAAgB;QACtB,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,kBAAkB;QACpD,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,yBAAyB;IAC7B,OAAO,CAAC,KAAY;QAClB,OAAO;YACL,GAAG,KAAK;YACR,MAAM,EAAE,QAAQ;YAChB,gBAAgB,EAAE,WAAW;YAC7B,YAAY,EAAE,SAAS;YACvB,cAAc,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACxC,WAAW,EAAE,IAAI,CAAC,oBAAoB,EAAE;SACzC,CAAC;IACJ,CAAC;IAEO,oBAAoB;QAC1B,MAAM,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QACxB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;CACF;AAED,+EAA+E;AAC/E,4BAA4B;AAC5B,+EAA+E;AAE/E;;;GAGG;AACH,MAAM,cAAc;IACV,UAAU,CAA0C;IAE5D;QACE,mCAAmC;QACnC,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,CAAC;YACxB,CAAC,SAAS,EAAE,IAAI,oBAAoB,EAAE,CAAC;YACvC,CAAC,UAAU,EAAE,IAAI,qBAAqB,EAAE,CAAC;YACzC,CAAC,cAAc,EAAE,IAAI,yBAAyB,EAAE,CAAC;SAClD,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,KAAY;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAEjD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,gDAAgD,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;QAChF,CAAC;QAED,OAAO,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,SAAiB,EAAE,QAAiC;QACnE,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAsB,EAAE,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACH,sBAAsB;QACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IAC5C,CAAC;CACF;AAED,+EAA+E;AAC/E,gBAAgB;AAChB,+EAA+E;AAE/E;;GAEG;AACH,SAAS,0BAA0B;IACjC,MAAM,SAAS,GAAG,IAAI,cAAc,EAAE,CAAC;IAEvC,iBAAiB;IACjB,MAAM,YAAY,GAAU;QAC1B,IAAI,EAAE,SAAS;QACf,EAAE,EAAE,SAAS;QACb,OAAO,EAAE,0BAA0B;QACnC,KAAK,EAAE,KAAK;KACb,CAAC;IAEF,MAAM,aAAa,GAAU;QAC3B,IAAI,EAAE,UAAU;QAChB,EAAE,EAAE,SAAS;QACb,OAAO,EAAE,cAAc;QACvB,KAAK,EAAE,MAAM;QACb,eAAe,EAAE,0BAA0B;KAC5C,CAAC;IAEF,MAAM,iBAAiB,GAAU;QAC/B,IAAI,EAAE,cAAc;QACpB,EAAE,EAAE,SAAS;QACb,OAAO,EAAE,mBAAmB;QAC5B,KAAK,EAAE,KAAK;KACb,CAAC;IAEF,iBAAiB;IACjB,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;IACzC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3E,OAAO,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;IAC5C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;IAChD,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,iBAAiB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;IAEhF,6BAA6B;IAC7B,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,SAAS,CAAC,sBAAsB,EAAE,CAAC,CAAC;AAC9E,CAAC;AAED,kCAAkC;AAClC,OAAO,EAIL,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,cAAc,EACf,CAAC;AAEF,gCAAgC;AAChC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,UAAU,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;AACrE,IAAI,YAAY,EAAE,CAAC;IACjB,0BAA0B,EAAE,CAAC;AAC/B,CAAC"}