@orchestr-sh/orchestr 1.6.1 → 1.7.0

package/dist/Events/EventServiceProvider.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventServiceProvider = void 0;
+const ServiceProvider_1 = require("../Foundation/ServiceProvider");
+const Dispatcher_1 = require("./Dispatcher");
+const fs = __importStar(require("fs"));
+/**
+ * Event Service Provider
+ *
+ * Provides event registration and discovery services following Laravel's
+ * EventServiceProvider pattern. Supports both manual registration and
+ * automatic listener discovery.
+ *
+ * @example
+ * ```typescript
+ * export class AppEventServiceProvider extends EventServiceProvider {
+ *   protected listen = {
+ *     'UserRegistered': [
+ *       'SendWelcomeEmail',
+ *       'CreateUserProfile'
+ *     ],
+ *     'OrderPlaced': 'SendOrderConfirmation'
+ *   }
+ *
+ *   protected subscribe = [
+ *     'UserEventSubscriber'
+ *   ]
+ * }
+ * ```
+ */
+class EventServiceProvider extends ServiceProvider_1.ServiceProvider {
+    /**
+     * The event listener mappings for the application
+     *
+     * Maps event names to listener class names (string) or arrays of listener names.
+     *
+     * @example
+     * ```typescript
+     * protected listen = {
+     *   'UserRegistered': ['SendWelcomeEmail', 'LogRegistration'],
+     *   'OrderPlaced': 'ProcessOrder'
+     * }
+     * ```
+     */
+    listen = {};
+    /**
+     * The subscriber classes to register
+     *
+     * Subscribers provide their own event-to-listener mappings via a subscribe() method.
+     *
+     * @example
+     * ```typescript
+     * protected subscribe = [
+     *   'UserEventSubscriber',
+     *   'OrderEventSubscriber'
+     * ]
+     * ```
+     */
+    subscribe = [];
+    /**
+     * Register the application's event listeners
+     *
+     * Binds the event dispatcher as a singleton in the container.
+     */
+    register() {
+        this.app.singleton('events', (app) => {
+            return new Dispatcher_1.Dispatcher(app);
+        });
+        // Register alias for convenience
+        this.app.alias('events', Dispatcher_1.Dispatcher);
+    }
+    /**
+     * Bootstrap the application events
+     *
+     * Performs three key operations:
+     * 1. Registers manual event-listener mappings from the `listen` property
+     * 2. Registers event subscribers from the `subscribe` property
+     * 3. Performs automatic event discovery if enabled
+     *
+     * @throws {Error} If the dispatcher cannot be resolved from the container
+     */
+    async boot() {
+        const events = this.app.make('events');
+        // Register event listeners from listen property
+        for (const [event, listeners] of Object.entries(this.listen)) {
+            const listenerArray = Array.isArray(listeners) ? listeners : [listeners];
+            for (const listener of listenerArray) {
+                events.listen(event, listener);
+            }
+        }
+        // Register event subscribers
+        for (const subscriber of this.subscribe) {
+            const subscriberInstance = this.app.make(subscriber);
+            events.subscribe(subscriberInstance);
+        }
+        // Perform event discovery if enabled
+        if (this.shouldDiscoverEvents()) {
+            await this.discoverEvents(events);
+        }
+    }
+    /**
+     * Determine if events and listeners should be automatically discovered
+     *
+     * By default, discovery is enabled unless events are cached.
+     * Override this method to customize discovery behavior.
+     *
+     * @returns {boolean} True if event discovery should run
+     *
+     * @example
+     * ```typescript
+     * protected shouldDiscoverEvents(): boolean {
+     *   // Disable discovery in production
+     *   return this.app.environment() !== 'production'
+     * }
+     * ```
+     */
+    shouldDiscoverEvents() {
+        // Check for cached events first
+        return !this.eventsAreCached();
+    }
+    /**
+     * Discover the events and listeners for the application
+     *
+     * Uses EventDiscovery to scan specified directories for listener classes
+     * and automatically registers them with their corresponding events.
+     *
+     * @param {Dispatcher} events - The event dispatcher instance
+     *
+     * @throws {Error} If EventDiscovery is not available (Task 6 dependency)
+     */
+    async discoverEvents(events) {
+        // Import EventDiscovery dynamically to avoid circular dependency
+        try {
+            const { EventDiscovery } = await Promise.resolve().then(() => __importStar(require('../Support/EventDiscovery')));
+            const discovery = new EventDiscovery(this.app);
+            const listeners = await discovery.discover(this.discoverEventsWithin());
+            for (const [event, listenerClasses] of listeners) {
+                for (const listener of listenerClasses) {
+                    events.listen(event, listener);
+                }
+            }
+        }
+        catch (error) {
+            // EventDiscovery not implemented yet (Task 6)
+            // Silently skip discovery for now
+            if (error.code !== 'MODULE_NOT_FOUND') {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Get the directories to discover events within
+     *
+     * By default, uses the paths configured via Application.withEvents()
+     * or falls back to the standard 'Listeners' directory.
+     *
+     * Override this method to customize discovery paths.
+     *
+     * @returns {string[]} Array of absolute directory paths to scan
+     *
+     * @example
+     * ```typescript
+     * protected discoverEventsWithin(): string[] {
+     *   return [
+     *     this.app.path('Listeners'),
+     *     this.app.path('Domain/Listeners')
+     *   ]
+     * }
+     * ```
+     */
+    discoverEventsWithin() {
+        return this.app.getEventDiscoveryPaths();
+    }
+    /**
+     * Determine if events are cached
+     *
+     * Checks for the existence of the cached events file.
+     *
+     * @returns {boolean} True if cached events file exists
+     */
+    eventsAreCached() {
+        const cachePath = this.app.storagePath('framework/events.json');
+        try {
+            fs.accessSync(cachePath, fs.constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the events and handlers from the cached file
+     *
+     * Loads and parses the cached events JSON file.
+     *
+     * @returns {Map<string, string[]>} Map of event names to listener class names
+     */
+    getCachedEvents() {
+        const cachePath = this.app.storagePath('framework/events.json');
+        if (!fs.existsSync(cachePath)) {
+            return new Map();
+        }
+        try {
+            const cached = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+            // Convert array of entries back to Map
+            return new Map(cached);
+        }
+        catch {
+            return new Map();
+        }
+    }
+    /**
+     * Get all registered event-listener mappings
+     *
+     * Returns the complete mapping of events to listeners for inspection.
+     * Useful for debugging and console commands.
+     *
+     * @returns {Record<string, string | string[]>} The listen property mappings
+     */
+    listens() {
+        return this.listen;
+    }
+}
+exports.EventServiceProvider = EventServiceProvider;
+//# sourceMappingURL=EventServiceProvider.js.map

package/dist/Events/EventServiceProvider.js.map

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

package/dist/Events/NullDispatcher.d.ts

@@ -0,0 +1,97 @@
+import type { DispatcherContract } from './Contracts/Dispatcher';
+import type { Event } from './Event';
+import type { EventListener, EventSubscriber } from './types';
+/**
+ * Null Dispatcher
+ *
+ * A no-op event dispatcher implementation following the Null Object pattern.
+ * Useful for testing or when you want to disable event dispatching entirely.
+ *
+ * All methods are implemented but do nothing, allowing code to call
+ * dispatcher methods without side effects.
+ *
+ * @example
+ * ```typescript
+ * // Use in tests to disable events
+ * const dispatcher = new NullDispatcher();
+ * container.instance('events', dispatcher);
+ *
+ * // Events will be "dispatched" but nothing happens
+ * dispatcher.dispatch(new UserRegistered(user));
+ * // No listeners are called
+ *
+ * // Use for performance when events aren't needed
+ * if (config.disableEvents) {
+ *   app.singleton('events', () => new NullDispatcher());
+ * }
+ * ```
+ */
+export declare class NullDispatcher implements DispatcherContract {
+    /**
+     * Register an event listener (no-op)
+     *
+     * @param events - Event name(s) to listen for (ignored)
+     * @param listener - Listener to invoke (ignored)
+     */
+    listen(events: string | string[], listener: EventListener): void;
+    /**
+     * Check if an event has any listeners (always returns false)
+     *
+     * @param eventName - The event name to check (ignored)
+     * @returns Always false
+     */
+    hasListeners(eventName: string): boolean;
+    /**
+     * Register an event subscriber (no-op)
+     *
+     * @param subscriber - The subscriber instance (ignored)
+     */
+    subscribe(subscriber: EventSubscriber): void;
+    /**
+     * Dispatch an event to all listeners (no-op, returns empty array)
+     *
+     * @param event - Event name or instance (ignored)
+     * @param payload - Additional arguments (ignored)
+     * @param halt - Stop on false return (ignored)
+     * @returns Empty array
+     */
+    dispatch(event: string | Event, payload?: any[], halt?: boolean): any[];
+    /**
+     * Dispatch an event until a listener returns a non-null response (always returns null)
+     *
+     * @param event - Event name or instance (ignored)
+     * @param payload - Additional arguments (ignored)
+     * @returns Always null
+     */
+    until(event: string | Event, payload?: any[]): any;
+    /**
+     * Queue an event for later dispatch (no-op)
+     *
+     * @param event - Event name (ignored)
+     * @param payload - Event payload (ignored)
+     */
+    push(event: string, payload?: any[]): void;
+    /**
+     * Flush all queued events (no-op)
+     *
+     * @param event - Event name to flush (ignored)
+     */
+    flush(event: string): void;
+    /**
+     * Remove all listeners for an event (no-op)
+     *
+     * @param event - Event name (ignored)
+     */
+    forget(event: string): void;
+    /**
+     * Clear all queued events (no-op)
+     */
+    forgetPushed(): void;
+    /**
+     * Get raw listener mappings (always returns empty map)
+     *
+     * @returns Empty Map
+     */
+    getRawListeners(): Map<string, EventListener[]>;
+}
+//# sourceMappingURL=NullDispatcher.d.ts.map

package/dist/Events/NullDispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NullDispatcher.d.ts","sourceRoot":"","sources":["../../src/Events/NullDispatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAe,YAAW,kBAAkB;IACvD;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI;IAIhE;;;;;OAKG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAIxC;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAI5C;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,GAAE,GAAG,EAAO,EAAE,IAAI,GAAE,OAAe,GAAG,GAAG,EAAE;IAIlF;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,OAAO,GAAE,GAAG,EAAO,GAAG,GAAG;IAItD;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,GAAG,EAAO,GAAG,IAAI;IAI9C;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI1B;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI3B;;OAEG;IACH,YAAY,IAAI,IAAI;IAIpB;;;;OAIG;IACH,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC;CAGhD"}

package/dist/Events/NullDispatcher.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NullDispatcher = void 0;
+/**
+ * Null Dispatcher
+ *
+ * A no-op event dispatcher implementation following the Null Object pattern.
+ * Useful for testing or when you want to disable event dispatching entirely.
+ *
+ * All methods are implemented but do nothing, allowing code to call
+ * dispatcher methods without side effects.
+ *
+ * @example
+ * ```typescript
+ * // Use in tests to disable events
+ * const dispatcher = new NullDispatcher();
+ * container.instance('events', dispatcher);
+ *
+ * // Events will be "dispatched" but nothing happens
+ * dispatcher.dispatch(new UserRegistered(user));
+ * // No listeners are called
+ *
+ * // Use for performance when events aren't needed
+ * if (config.disableEvents) {
+ *   app.singleton('events', () => new NullDispatcher());
+ * }
+ * ```
+ */
+class NullDispatcher {
+    /**
+     * Register an event listener (no-op)
+     *
+     * @param events - Event name(s) to listen for (ignored)
+     * @param listener - Listener to invoke (ignored)
+     */
+    listen(events, listener) {
+        // No-op
+    }
+    /**
+     * Check if an event has any listeners (always returns false)
+     *
+     * @param eventName - The event name to check (ignored)
+     * @returns Always false
+     */
+    hasListeners(eventName) {
+        return false;
+    }
+    /**
+     * Register an event subscriber (no-op)
+     *
+     * @param subscriber - The subscriber instance (ignored)
+     */
+    subscribe(subscriber) {
+        // No-op
+    }
+    /**
+     * Dispatch an event to all listeners (no-op, returns empty array)
+     *
+     * @param event - Event name or instance (ignored)
+     * @param payload - Additional arguments (ignored)
+     * @param halt - Stop on false return (ignored)
+     * @returns Empty array
+     */
+    dispatch(event, payload = [], halt = false) {
+        return [];
+    }
+    /**
+     * Dispatch an event until a listener returns a non-null response (always returns null)
+     *
+     * @param event - Event name or instance (ignored)
+     * @param payload - Additional arguments (ignored)
+     * @returns Always null
+     */
+    until(event, payload = []) {
+        return null;
+    }
+    /**
+     * Queue an event for later dispatch (no-op)
+     *
+     * @param event - Event name (ignored)
+     * @param payload - Event payload (ignored)
+     */
+    push(event, payload = []) {
+        // No-op
+    }
+    /**
+     * Flush all queued events (no-op)
+     *
+     * @param event - Event name to flush (ignored)
+     */
+    flush(event) {
+        // No-op
+    }
+    /**
+     * Remove all listeners for an event (no-op)
+     *
+     * @param event - Event name (ignored)
+     */
+    forget(event) {
+        // No-op
+    }
+    /**
+     * Clear all queued events (no-op)
+     */
+    forgetPushed() {
+        // No-op
+    }
+    /**
+     * Get raw listener mappings (always returns empty map)
+     *
+     * @returns Empty Map
+     */
+    getRawListeners() {
+        return new Map();
+    }
+}
+exports.NullDispatcher = NullDispatcher;
+//# sourceMappingURL=NullDispatcher.js.map

package/dist/Events/NullDispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NullDispatcher.js","sourceRoot":"","sources":["../../src/Events/NullDispatcher.ts"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,cAAc;IACzB;;;;;OAKG;IACH,MAAM,CAAC,MAAyB,EAAE,QAAuB;QACvD,QAAQ;IACV,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,SAAiB;QAC5B,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,UAA2B;QACnC,QAAQ;IACV,CAAC;IAED;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAqB,EAAE,UAAiB,EAAE,EAAE,OAAgB,KAAK;QACxE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAqB,EAAE,UAAiB,EAAE;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,KAAa,EAAE,UAAiB,EAAE;QACrC,QAAQ;IACV,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAa;QACjB,QAAQ;IACV,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAa;QAClB,QAAQ;IACV,CAAC;IAED;;OAEG;IACH,YAAY;QACV,QAAQ;IACV,CAAC;IAED;;;;OAIG;IACH,eAAe;QACb,OAAO,IAAI,GAAG,EAAE,CAAC;IACnB,CAAC;CACF;AAhGD,wCAgGC"}

package/dist/Events/PendingDispatch.d.ts

@@ -0,0 +1,119 @@
+import type { Event } from './Event';
+import type { DispatcherContract } from './Contracts/Dispatcher';
+/**
+ * Pending Dispatch
+ *
+ * A deferred dispatch helper that allows chaining configuration
+ * before actually dispatching an event.
+ *
+ * This is useful for building fluent APIs around event dispatching,
+ * similar to Laravel's job dispatching.
+ *
+ * @example
+ * ```typescript
+ * // Defer dispatch with configuration
+ * const pending = new PendingDispatch(dispatcher, new UserRegistered(user));
+ * pending
+ *   .onConnection('redis')
+ *   .onQueue('notifications')
+ *   .delay(60)
+ *   .dispatch();
+ *
+ * // Or dispatch immediately with configuration
+ * PendingDispatch.for(dispatcher, new OrderPlaced(order))
+ *   .delay(300)
+ *   .dispatch();
+ * ```
+ */
+export declare class PendingDispatch {
+    protected dispatcher: DispatcherContract;
+    protected event: Event;
+    /**
+     * Event configuration options
+     */
+    protected options: {
+        connection?: string;
+        queue?: string;
+        delay?: number;
+    };
+    /**
+     * Create a new pending dispatch instance
+     *
+     * @param dispatcher - The event dispatcher
+     * @param event - The event to dispatch
+     */
+    constructor(dispatcher: DispatcherContract, event: Event);
+    /**
+     * Static factory method for fluent API
+     *
+     * @param dispatcher - The event dispatcher
+     * @param event - The event to dispatch
+     * @returns PendingDispatch instance
+     */
+    static for(dispatcher: DispatcherContract, event: Event): PendingDispatch;
+    /**
+     * Set the queue connection for the event
+     *
+     * Only applicable if the event's listeners are queued
+     *
+     * @param connection - Connection name
+     * @returns This instance for chaining
+     */
+    onConnection(connection: string): this;
+    /**
+     * Set the queue for the event
+     *
+     * Only applicable if the event's listeners are queued
+     *
+     * @param queue - Queue name
+     * @returns This instance for chaining
+     */
+    onQueue(queue: string): this;
+    /**
+     * Set the delay before dispatching
+     *
+     * @param delay - Delay in seconds
+     * @returns This instance for chaining
+     */
+    delay(delay: number): this;
+    /**
+     * Set the delay before dispatching (alias for delay)
+     *
+     * @param delay - Delay in seconds
+     * @returns This instance for chaining
+     */
+    afterDelay(delay: number): this;
+    /**
+     * Apply the configured options to the event
+     *
+     * @returns The configured event
+     */
+    protected applyOptions(): Event;
+    /**
+     * Dispatch the event to all listeners
+     *
+     * @returns Array of results from listeners
+     */
+    dispatch(): any[];
+    /**
+     * Dispatch the event until the first listener returns a non-null response
+     *
+     * @returns The first non-null response
+     */
+    until(): any;
+    /**
+     * Conditionally dispatch the event
+     *
+     * @param condition - Boolean or function returning boolean
+     * @returns Array of results or empty array
+     */
+    dispatchIf(condition: boolean | (() => boolean)): any[];
+    /**
+     * Dispatch unless the condition is true
+     *
+     * @param condition - Boolean or function returning boolean
+     * @returns Array of results or empty array
+     */
+    dispatchUnless(condition: boolean | (() => boolean)): any[];
+}
+//# sourceMappingURL=PendingDispatch.d.ts.map

package/dist/Events/PendingDispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PendingDispatch.d.ts","sourceRoot":"","sources":["../../src/Events/PendingDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,eAAe;IAiBxB,SAAS,CAAC,UAAU,EAAE,kBAAkB;IACxC,SAAS,CAAC,KAAK,EAAE,KAAK;IAjBxB;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAM;IAEP;;;;;OAKG;gBAES,UAAU,EAAE,kBAAkB,EAC9B,KAAK,EAAE,KAAK;IAGxB;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,KAAK,GAAG,eAAe;IAIzE;;;;;;;OAOG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAKtC;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK5B;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK1B;;;;;OAKG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAI/B;;;;OAIG;IACH,SAAS,CAAC,YAAY,IAAI,KAAK;IAgB/B;;;;OAIG;IACH,QAAQ,IAAI,GAAG,EAAE;IAKjB;;;;OAIG;IACH,KAAK,IAAI,GAAG;IAKZ;;;;;OAKG;IACH,UAAU,CAAC,SAAS,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,GAAG,EAAE;IAUvD;;;;;OAKG;IACH,cAAc,CAAC,SAAS,EAAE,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,GAAG,GAAG,EAAE;CAS5D"}