@hawsen-the-first/interactiv 0.0.1

package/dist/src/screensaverManager.d.ts

@@ -0,0 +1,66 @@
+import { EventOrchestrator } from "./eventBus";
+import { Page } from "./appBuilder";
+import { NavigationManager, type TransitionConfig } from "./navigationManager";
+export interface ScreensaverConfig {
+    timeoutSeconds: number;
+    page: Page;
+    defaultViewId?: string;
+    screensaverViewBehavior?: "default" | "specific" | "return";
+    specificViewId?: string;
+    transitionConfig?: TransitionConfig;
+    exitBehavior?: "reset" | "return";
+    startingPageId?: string;
+    startingViewId?: string;
+    activityEvents?: string[];
+    excludeSelectors?: string[];
+    activateCallback?: () => void;
+    deactivateCallback?: () => void;
+    blockerCallback?: () => boolean;
+    rebootTimeout?: number | null;
+    rebootCallback?: () => void;
+}
+export declare class ScreensaverManager {
+    private eventBus;
+    private orchestrator;
+    private navigationManager;
+    private config;
+    private activityTimer;
+    private rebootCheckInterval;
+    private isScreensaverActive;
+    private lastActivePageId;
+    private lastActiveViewId;
+    private lastScreensaverViewId;
+    private lastActivityResetTime;
+    private globalListeners;
+    private readonly DEBOUNCE_INTERVAL;
+    private readonly DEFAULT_ACTIVITY_EVENTS;
+    constructor(orchestrator: EventOrchestrator, navigationManager: NavigationManager);
+    private initializeGlobalState;
+    private setupEventListeners;
+    registerScreensaver(config: ScreensaverConfig): void;
+    private validateConfig;
+    private setupGlobalActivityListeners;
+    private shouldIgnoreActivity;
+    private resetActivityTimer;
+    private pauseActivityTimer;
+    private clearActivityTimer;
+    private activateScreensaver;
+    private determineScreensaverView;
+    private handleScreensaverExit;
+    private deactivateScreensaver;
+    isActive(): boolean;
+    getCurrentConfig(): ScreensaverConfig | null;
+    getLastActivePageId(): string | null;
+    getLastActiveViewId(): string | null;
+    getLastScreensaverViewId(): string | null;
+    forceActivate(): void;
+    forceDeactivate(): void;
+    resetTimer(): void;
+    private cleanup;
+    destroy(): void;
+    private hasRebootTimeoutElapsed;
+    private checkAndPerformReboot;
+    private startRebootCheckInterval;
+    private stopRebootCheckInterval;
+}
+//# sourceMappingURL=screensaverManager.d.ts.map

package/dist/src/screensaverManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screensaverManager.d.ts","sourceRoot":"","sources":["../../src/screensaverManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM/E,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,IAAI,CAAC;IACX,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uBAAuB,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,OAAO,CAAC;IAChC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAkC;IAChD,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,mBAAmB,CAAuB;IAClD,OAAO,CAAC,mBAAmB,CAAkB;IAC7C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,eAAe,CAIf;IAGR,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;IAG1C,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAStC;gBAEU,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB;IASjF,OAAO,CAAC,qBAAqB;IAkB7B,OAAO,CAAC,mBAAmB;IAwCpB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAiC3D,OAAO,CAAC,cAAc;IA0BtB,OAAO,CAAC,4BAA4B;IAmDpC,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,kBAAkB;IAe1B,OAAO,CAAC,kBAAkB;IAO1B,OAAO,CAAC,kBAAkB;YAOZ,mBAAmB;IAkDjC,OAAO,CAAC,wBAAwB;YAclB,qBAAqB;YAmDrB,qBAAqB;IAI5B,QAAQ,IAAI,OAAO;IAInB,gBAAgB,IAAI,iBAAiB,GAAG,IAAI;IAI5C,mBAAmB,IAAI,MAAM,GAAG,IAAI;IAIpC,mBAAmB,IAAI,MAAM,GAAG,IAAI;IAIpC,wBAAwB,IAAI,MAAM,GAAG,IAAI;IAKzC,aAAa,IAAI,IAAI;IAKrB,eAAe,IAAI,IAAI;IAIvB,UAAU,IAAI,IAAI;IAMzB,OAAO,CAAC,OAAO;IAcR,OAAO,IAAI,IAAI;IAUtB,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,qBAAqB;IAc7B,OAAO,CAAC,wBAAwB;IAchC,OAAO,CAAC,uBAAuB;CAOhC"}

package/dist/src/screensaverManager.js

@@ -0,0 +1,417 @@
+import { stateManager } from "./stateManager";
+import { logger } from "./logger";
+const log = logger;
+export class ScreensaverManager {
+    eventBus;
+    orchestrator;
+    navigationManager;
+    config = null;
+    activityTimer = null;
+    rebootCheckInterval = null;
+    isScreensaverActive = false;
+    lastActivePageId = null;
+    lastActiveViewId = null;
+    lastScreensaverViewId = null;
+    lastActivityResetTime = null;
+    globalListeners = [];
+    // Debounce interval for activity timer resets (in milliseconds)
+    DEBOUNCE_INTERVAL = 1000;
+    // Default activity events to monitor
+    DEFAULT_ACTIVITY_EVENTS = [
+        "mousemove",
+        "click",
+        "keydown",
+        "keypress",
+        "touchstart",
+        "touchmove",
+        "wheel",
+        "scroll",
+    ];
+    constructor(orchestrator, navigationManager) {
+        this.orchestrator = orchestrator;
+        this.navigationManager = navigationManager;
+        this.eventBus = orchestrator.registerEventBus("screensaver-manager");
+        this.setupEventListeners();
+        this.initializeGlobalState();
+    }
+    initializeGlobalState() {
+        if (!stateManager.has("screensaver.isActive")) {
+            stateManager.set("screensaver.isActive", false);
+        }
+        if (!stateManager.has("screensaver.lastActivePageId")) {
+            stateManager.set("screensaver.lastActivePageId", null);
+        }
+        if (!stateManager.has("screensaver.lastActiveViewId")) {
+            stateManager.set("screensaver.lastActiveViewId", null);
+        }
+        if (!stateManager.has("screensaver.lastScreensaverViewId")) {
+            stateManager.set("screensaver.lastScreensaverViewId", null);
+        }
+        if (!stateManager.has("lastReboot")) {
+            stateManager.set("lastReboot", Date.now());
+        }
+    }
+    setupEventListeners() {
+        this.eventBus.on("register-screensaver", (e) => {
+            const { config } = e.detail;
+            this.registerScreensaver(config);
+        });
+        this.eventBus.on("activate-screensaver", () => {
+            this.activateScreensaver();
+        });
+        this.eventBus.on("deactivate-screensaver", () => {
+            this.deactivateScreensaver();
+        });
+        // Listen for navigation changes to track active pages and views
+        const navBus = this.orchestrator.getEventBus("navigation-manager");
+        if (navBus) {
+            navBus.on("page-changed", (e) => {
+                const { newPageId } = e.detail;
+                if (!this.isScreensaverActive && newPageId !== this.config?.page.componentId) {
+                    this.lastActivePageId = newPageId;
+                    stateManager.set("screensaver.lastActivePageId", newPageId);
+                }
+            });
+            navBus.on("view-changed", (e) => {
+                const { newViewId } = e.detail;
+                if (this.isScreensaverActive) {
+                    // Track view changes within screensaver for "return" behavior
+                    this.lastScreensaverViewId = newViewId;
+                    stateManager.set("screensaver.lastScreensaverViewId", newViewId);
+                }
+                else {
+                    this.lastActiveViewId = newViewId;
+                    stateManager.set("screensaver.lastActiveViewId", newViewId);
+                    // Timer reset is handled by activity event listeners, not navigation events
+                }
+            });
+        }
+    }
+    registerScreensaver(config) {
+        this.validateConfig(config);
+        // Clean up existing screensaver if any
+        if (this.config) {
+            this.cleanup();
+        }
+        this.config = {
+            ...config,
+            exitBehavior: config.exitBehavior || "reset",
+            screensaverViewBehavior: config.screensaverViewBehavior || "default",
+            activityEvents: config.activityEvents || this.DEFAULT_ACTIVITY_EVENTS,
+            excludeSelectors: config.excludeSelectors || [],
+            transitionConfig: config.transitionConfig || {
+                type: "snap",
+            },
+        };
+        // Register the screensaver page with navigation manager
+        const navBus = this.orchestrator.getEventBus("navigation-manager");
+        if (navBus) {
+            navBus.emit("register-page", { page: this.config.page });
+        }
+        this.setupGlobalActivityListeners();
+        this.resetActivityTimer();
+        log.trace(`Screensaver registered with ${config.timeoutSeconds}s timeout and '${this.config.exitBehavior}' exit behavior`);
+    }
+    validateConfig(config) {
+        if (!config.page) {
+            throw new Error("Screensaver page is required");
+        }
+        if (config.timeoutSeconds <= 0) {
+            throw new Error("timeoutSeconds must be greater than 0");
+        }
+        if (config.exitBehavior === "reset" && !config.startingPageId) {
+            throw new Error('startingPageId is required when exitBehavior is "reset"');
+        }
+        if (config.exitBehavior && !["reset", "return"].includes(config.exitBehavior)) {
+            throw new Error('exitBehavior must be either "reset" or "return"');
+        }
+        if (config.screensaverViewBehavior === "specific" && !config.specificViewId) {
+            throw new Error('specificViewId is required when screensaverViewBehavior is "specific"');
+        }
+        if (config.screensaverViewBehavior && !["default", "specific", "return"].includes(config.screensaverViewBehavior)) {
+            throw new Error('screensaverViewBehavior must be "default", "specific", or "return"');
+        }
+    }
+    setupGlobalActivityListeners() {
+        if (!this.config)
+            return;
+        const activityHandler = (event) => {
+            // Check if event should be ignored based on excludeSelectors
+            if (this.shouldIgnoreActivity(event)) {
+                return;
+            }
+            if (this.isScreensaverActive) {
+                // If screensaver is active, any activity should exit it
+                this.handleScreensaverExit();
+            }
+            else {
+                // If screensaver is not active, check debounce before resetting the timer
+                const now = Date.now();
+                if (this.lastActivityResetTime === null ||
+                    now - this.lastActivityResetTime >= this.DEBOUNCE_INTERVAL) {
+                    this.resetActivityTimer();
+                }
+            }
+        };
+        // Add listeners to document for global coverage
+        this.config.activityEvents.forEach((eventType) => {
+            const listener = activityHandler.bind(this);
+            document.addEventListener(eventType, listener, { passive: true });
+            this.globalListeners.push({
+                element: document,
+                type: eventType,
+                listener,
+            });
+        });
+        // Also listen for visibility changes (tab switching, etc.)
+        const visibilityHandler = () => {
+            if (document.hidden) {
+                this.pauseActivityTimer();
+            }
+            else {
+                this.resetActivityTimer();
+            }
+        };
+        document.addEventListener("visibilitychange", visibilityHandler);
+        this.globalListeners.push({
+            element: document,
+            type: "visibilitychange",
+            listener: visibilityHandler,
+        });
+    }
+    shouldIgnoreActivity(event) {
+        if (!this.config?.excludeSelectors?.length)
+            return false;
+        const target = event.target;
+        if (!target)
+            return false;
+        return this.config.excludeSelectors.some((selector) => {
+            try {
+                return target.matches(selector) || target.closest(selector);
+            }
+            catch (e) {
+                log.warn(`Invalid exclude selector: ${selector} ${e.message}`);
+                return false;
+            }
+        });
+    }
+    resetActivityTimer() {
+        if (!this.config)
+            return;
+        this.clearActivityTimer();
+        this.activityTimer = window.setTimeout(() => {
+            this.activateScreensaver();
+        }, this.config.timeoutSeconds * 1000);
+        // Record the timestamp for debouncing
+        this.lastActivityResetTime = Date.now();
+        log.trace(`Activity timer reset for ${this.config.timeoutSeconds} seconds`);
+    }
+    pauseActivityTimer() {
+        this.clearActivityTimer();
+        // Reset the debounce timestamp when pausing
+        this.lastActivityResetTime = null;
+        log.trace("Activity timer paused");
+    }
+    clearActivityTimer() {
+        if (this.activityTimer !== null) {
+            clearTimeout(this.activityTimer);
+            this.activityTimer = null;
+        }
+    }
+    async activateScreensaver() {
+        if (!this.config || this.isScreensaverActive)
+            return;
+        if (this.config.blockerCallback && this.config.blockerCallback()) {
+            this.resetActivityTimer();
+            return;
+        }
+        log.trace("Activating screensaver");
+        // Store the current page and view before switching to screensaver
+        const currentPageId = this.navigationManager.getCurrentPageId();
+        const currentViewId = this.navigationManager.getCurrentViewId();
+        if (currentPageId && currentPageId !== this.config.page.componentId) {
+            this.lastActivePageId = currentPageId;
+            this.lastActiveViewId = currentViewId;
+            stateManager.set("screensaver.lastActivePageId", currentPageId);
+            stateManager.set("screensaver.lastActiveViewId", currentViewId);
+        }
+        this.isScreensaverActive = true;
+        stateManager.set("screensaver.isActive", true);
+        try {
+            // Navigate to screensaver page
+            await this.navigationManager.navigateToPage(this.config.page.componentId, this.config.transitionConfig);
+            // Determine which view to show based on screensaverViewBehavior
+            const targetViewId = this.determineScreensaverView();
+            if (targetViewId) {
+                await this.navigationManager.navigateToView(targetViewId, { type: "snap" });
+            }
+            this.eventBus.emit("screensaver-activated", {
+                pageId: this.config.page.componentId,
+                viewId: targetViewId,
+                previousPageId: this.lastActivePageId,
+                previousViewId: this.lastActiveViewId,
+            });
+        }
+        catch (error) {
+            log.error("Failed to activate screensaver:", error);
+            this.isScreensaverActive = false;
+            stateManager.set("screensaver.isActive", false);
+        }
+        if (this.config.activateCallback)
+            this.config.activateCallback();
+        // Start periodic reboot check and check immediately
+        this.startRebootCheckInterval();
+        this.checkAndPerformReboot();
+    }
+    determineScreensaverView() {
+        if (!this.config)
+            return null;
+        switch (this.config.screensaverViewBehavior) {
+            case "return":
+                return this.lastScreensaverViewId || this.config.defaultViewId || null;
+            case "specific":
+                return this.config.specificViewId || null;
+            case "default":
+            default:
+                return this.config.defaultViewId || null;
+        }
+    }
+    async handleScreensaverExit() {
+        if (!this.config || !this.isScreensaverActive)
+            return;
+        log.trace(`Exiting screensaver with '${this.config.exitBehavior}' behavior`);
+        // Stop the reboot check interval
+        this.stopRebootCheckInterval();
+        if (this.config.deactivateCallback)
+            this.config.deactivateCallback();
+        this.isScreensaverActive = false;
+        stateManager.set("screensaver.isActive", false);
+        let targetPageId = null;
+        let targetViewId = null;
+        if (this.config.exitBehavior === "return") {
+            targetPageId = this.lastActivePageId;
+            targetViewId = this.lastActiveViewId;
+        }
+        else if (this.config.exitBehavior === "reset") {
+            targetPageId = this.config.startingPageId || null;
+            targetViewId = this.config.startingViewId || null;
+        }
+        if (targetPageId) {
+            try {
+                await this.navigationManager.navigateToPage(targetPageId, this.config.transitionConfig);
+                if (targetViewId) {
+                    await this.navigationManager.navigateToView(targetViewId, { type: "snap" });
+                }
+                this.eventBus.emit("screensaver-deactivated", {
+                    targetPageId,
+                    targetViewId,
+                    exitBehavior: this.config.exitBehavior,
+                });
+                // Reset timer for next cycle
+                this.resetActivityTimer();
+            }
+            catch (error) {
+                log.error("Failed to exit screensaver:", error);
+                // Reset state on error
+                this.isScreensaverActive = true;
+                stateManager.set("screensaver.isActive", true);
+            }
+        }
+        else {
+            log.warn("No target page available for screensaver exit");
+            this.resetActivityTimer();
+        }
+    }
+    async deactivateScreensaver() {
+        await this.handleScreensaverExit();
+    }
+    isActive() {
+        return this.isScreensaverActive;
+    }
+    getCurrentConfig() {
+        return this.config;
+    }
+    getLastActivePageId() {
+        return this.lastActivePageId;
+    }
+    getLastActiveViewId() {
+        return this.lastActiveViewId;
+    }
+    getLastScreensaverViewId() {
+        return this.lastScreensaverViewId;
+    }
+    // Manual control methods
+    forceActivate() {
+        this.clearActivityTimer();
+        this.activateScreensaver();
+    }
+    forceDeactivate() {
+        this.deactivateScreensaver();
+    }
+    resetTimer() {
+        if (!this.isScreensaverActive) {
+            this.resetActivityTimer();
+        }
+    }
+    cleanup() {
+        this.clearActivityTimer();
+        this.stopRebootCheckInterval();
+        // Remove all global event listeners
+        this.globalListeners.forEach(({ element, type, listener }) => {
+            element.removeEventListener(type, listener);
+        });
+        this.globalListeners.length = 0;
+        this.isScreensaverActive = false;
+        stateManager.set("screensaver.isActive", false);
+    }
+    destroy() {
+        this.cleanup();
+        this.config = null;
+        this.lastActivePageId = null;
+        this.lastActiveViewId = null;
+        this.lastScreensaverViewId = null;
+        log.trace("ScreensaverManager destroyed");
+    }
+    // Reboot timeout checking methods
+    hasRebootTimeoutElapsed() {
+        if (!this.config?.rebootTimeout)
+            return false;
+        const lastReboot = stateManager.get("lastReboot");
+        if (!lastReboot) {
+            // Initialize timestamp on first check
+            stateManager.set("lastReboot", Date.now());
+            return false;
+        }
+        const elapsedMinutes = (Date.now() - lastReboot) / (1000 * 60);
+        return elapsedMinutes >= this.config.rebootTimeout;
+    }
+    checkAndPerformReboot() {
+        if (!this.hasRebootTimeoutElapsed())
+            return;
+        log.trace("Reboot timeout elapsed, performing reboot");
+        // Call the reboot callback function
+        if (this.config?.rebootCallback) {
+            this.config.rebootCallback();
+        }
+        // Reset the timestamp after reboot is triggered
+        stateManager.set("lastReboot", Date.now());
+    }
+    startRebootCheckInterval() {
+        if (!this.config?.rebootTimeout)
+            return;
+        // Clear any existing interval
+        this.stopRebootCheckInterval();
+        // Check every 10 minutes (600000 ms)
+        this.rebootCheckInterval = window.setInterval(() => {
+            this.checkAndPerformReboot();
+        }, 600000);
+        log.trace("Reboot check interval started (10 minute intervals)");
+    }
+    stopRebootCheckInterval() {
+        if (this.rebootCheckInterval !== null) {
+            clearInterval(this.rebootCheckInterval);
+            this.rebootCheckInterval = null;
+            log.trace("Reboot check interval stopped");
+        }
+    }
+}

package/dist/src/settingsManager.d.ts

@@ -0,0 +1,48 @@
+import { EventOrchestrator } from "./eventBus";
+import { View } from "./appBuilder";
+import { NavigationManager, type TransitionConfig } from "./navigationManager";
+export interface SettingsConfig {
+    view: View;
+    transitionConfig?: TransitionConfig;
+    exitBehavior?: "reset" | "return";
+    startingViewId?: string;
+    cornerTouchRadius?: number;
+    touchTimeout?: number;
+    debugMode?: boolean;
+}
+export declare class SettingsManager {
+    private eventBus;
+    private orchestrator;
+    private navigationManager;
+    private config;
+    private isSettingsActive;
+    private lastActiveViewId;
+    private touchSequenceState;
+    private lastEventTime;
+    private touchListeners;
+    private readonly DEFAULT_CORNER_RADIUS;
+    private readonly DEFAULT_TOUCH_TIMEOUT;
+    private readonly EVENT_DEBOUNCE_MS;
+    constructor(orchestrator: EventOrchestrator, navigationManager: NavigationManager);
+    private initializeGlobalState;
+    private setupEventListeners;
+    registerSettings(config: SettingsConfig): void;
+    private validateConfig;
+    private setupCornerTouchListeners;
+    private handleTouchAttempt;
+    private detectCornerTouch;
+    private getExpectedCorner;
+    private resetTouchSequence;
+    private activateSettings;
+    private handleSettingsExit;
+    private deactivateSettings;
+    isActive(): boolean;
+    getCurrentConfig(): SettingsConfig | null;
+    getLastActiveViewId(): string | null;
+    forceActivate(): void;
+    forceDeactivate(): void;
+    resetSequence(): void;
+    private cleanup;
+    destroy(): void;
+}
+//# sourceMappingURL=settingsManager.d.ts.map

package/dist/src/settingsManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settingsManager.d.ts","sourceRoot":"","sources":["../../src/settingsManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAM/E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,IAAI,CAAC;IACX,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAOD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,kBAAkB,CAGxB;IACF,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,cAAc,CAId;IAGR,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAO;IAC7C,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAC9C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAM;gBAE5B,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB;IASjF,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,mBAAmB;IA2BpB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAkCrD,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,yBAAyB;IAwBjC,OAAO,CAAC,kBAAkB;IA+D1B,OAAO,CAAC,iBAAiB;IA4BzB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,kBAAkB;YAQZ,gBAAgB;YA6BhB,kBAAkB;YAmClB,kBAAkB;IAIzB,QAAQ,IAAI,OAAO;IAInB,gBAAgB,IAAI,cAAc,GAAG,IAAI;IAIzC,mBAAmB,IAAI,MAAM,GAAG,IAAI;IAKpC,aAAa,IAAI,IAAI;IAKrB,eAAe,IAAI,IAAI;IAIvB,aAAa,IAAI,IAAI;IAI5B,OAAO,CAAC,OAAO;IAYR,OAAO,IAAI,IAAI;CAMvB"}