rx-hotkeys 2.4.1 → 2.6.0

package/dist/ttt.js

@@ -0,0 +1,439 @@
+import { fromEvent, BehaviorSubject, EMPTY, filter, map, bufferCount, withLatestFrom, tap, catchError, scan, merge, } from "rxjs";
+// --- Enums, Interfaces and Types ---
+export var ShortcutTypes;
+(function (ShortcutTypes) {
+    ShortcutTypes["Combination"] = "combination";
+    ShortcutTypes["Sequence"] = "sequence";
+})(ShortcutTypes || (ShortcutTypes = {}));
+var EmitStates;
+(function (EmitStates) {
+    EmitStates[EmitStates["Emit"] = 0] = "Emit";
+    EmitStates[EmitStates["Ignore"] = 1] = "Ignore";
+    EmitStates[EmitStates["InProgress"] = 2] = "InProgress";
+})(EmitStates || (EmitStates = {}));
+// --- Helper function to compare keys ---
+/**
+ * Compares a browser event's key with a configured key.
+ * - For single character keys (e.g., "a", "A", "7"), comparison is case-insensitive.
+ * - For multi-character special keys (e.g., "Enter", "ArrowUp"), comparison is case-sensitive.
+ */
+function compareKey(eventKey, configuredKey) {
+    if (configuredKey.length === 1 && eventKey.length === 1) {
+        return eventKey.toLowerCase() === configuredKey.toLowerCase();
+    }
+    return eventKey === configuredKey;
+}
+// --- Hotkeys Library ---
+/**
+ * Manages keyboard shortcuts for web applications.
+ * Allows registration of single key combinations (e.g., Ctrl+S) and key sequences (e.g., g -> i).
+ * Supports contexts to enable/disable shortcuts based on application state.
+ */
+export class Hotkeys {
+    static KEYDOWN_EVENT = "keydown";
+    static LOG_PREFIX = "Hotkeys:";
+    keydown$;
+    activeContext$;
+    activeShortcuts;
+    debugMode;
+    /**
+     * Creates an instance of Hotkeys.
+     * @param initialContext - Optional initial context name. Shortcuts will only trigger if their context matches this, or if they have no context defined.
+     * @param debugMode - Optional. If true, debug messages will be logged to the console. Defaults to false.
+     * @throws Error if not in a browser environment (i.e., `document` or `performance` is undefined).
+     */
+    constructor(initialContext = null, debugMode = false) {
+        this.debugMode = debugMode;
+        if (typeof document === "undefined" || typeof performance === "undefined") {
+            throw new Error(`${Hotkeys.LOG_PREFIX} Hotkeys can only be used in a browser environment with global "document" and "performance" objects.`);
+        }
+        this.keydown$ = fromEvent(document, Hotkeys.KEYDOWN_EVENT);
+        this.activeContext$ = new BehaviorSubject(initialContext);
+        this.activeShortcuts = new Map();
+        if (this.debugMode) {
+            console.log(`${Hotkeys.LOG_PREFIX} Library initialized. Initial context: "${initialContext}". Debug mode: ${debugMode}.`);
+        }
+    }
+    /**
+     * Sets the active context for shortcuts.
+     * Only shortcuts matching this context (or shortcuts with no specific context defined)
+     * will be active and can be triggered.
+     * @param contextName - The name of the context (e.g., "modal", "editor", "global").
+     * Pass `null` to activate shortcuts with no context or to deactivate context-specific shortcuts.
+     * @returns `true` if the context was changed, `false` if the new context was the same as the current one.
+     */
+    setContext(contextName) {
+        const currentContext = this.activeContext$.getValue();
+        if (currentContext === contextName) {
+            if (this.debugMode) {
+                // Optional: Log that no change is happening, or simply do nothing.
+                console.log(`${Hotkeys.LOG_PREFIX} setContext called with the same context "${contextName}". No change made.`);
+            }
+            return false; // Context was NOT updated
+        }
+        // If we reach here, the context is actually changing.
+        if (this.debugMode) {
+            console.log(`${Hotkeys.LOG_PREFIX} Context changed from "${currentContext}" to "${contextName}".`);
+        }
+        this.activeContext$.next(contextName);
+        return true; // Context WAS updated
+    }
+    /**
+     * Gets the current active context.
+     * @returns The current context name as a string, or `null` if no context is set.
+     */
+    getContext() {
+        return this.activeContext$.getValue();
+    }
+    /**
+     * Enables or disables debug logging for the Hotkeys instance.
+     * When enabled, various internal actions and shortcut triggers will be logged to the console.
+     * @param enable - True to enable debug logs, false to disable.
+     */
+    setDebugMode(enable) {
+        if (this.debugMode === enable) {
+            return;
+        }
+        this.debugMode = enable;
+        if (enable) {
+            console.log(`${Hotkeys.LOG_PREFIX} Debug mode enabled.`);
+        }
+        else {
+            console.log(`${Hotkeys.LOG_PREFIX} Debug mode disabled.`);
+        }
+    }
+    /**
+     * Checks if a shortcut with the given ID is currently registered and active.
+     * @param id - The unique ID of the shortcut to check.
+     * @returns True if a shortcut with the specified ID exists, false otherwise.
+     */
+    hasShortcut(id) {
+        return this.activeShortcuts.has(id);
+    }
+    /**
+     * An Observable that emits the new context name (or null) whenever the active context changes.
+     */
+    get onContextChange$() {
+        return this.activeContext$.asObservable();
+    }
+    _areSequencesIdentical(seq1, seq2) {
+        if (seq1.length !== seq2.length) {
+            return false;
+        }
+        for (let i = 0; i < seq1.length; i++) {
+            if (seq1[i] !== seq2[i]) { // Direct comparison for canonical StandardKey values
+                return false;
+            }
+        }
+        return true;
+    }
+    _shortcutMatchesEvent(shortcutConfig, event) {
+        const keyTriggers = Array.isArray(shortcutConfig.keys) ? shortcutConfig.keys : [shortcutConfig.keys];
+        for (const keyInput of keyTriggers) {
+            let configuredMainKey;
+            let ctrlKeyConfig;
+            let altKeyConfig;
+            let shiftKeyConfig;
+            let metaKeyConfig;
+            if (typeof keyInput === "string") {
+                if (keyInput === "")
+                    continue; // Invalid trigger, skip
+                configuredMainKey = keyInput;
+                ctrlKeyConfig = false;
+                altKeyConfig = false;
+                shiftKeyConfig = false;
+                metaKeyConfig = false;
+            }
+            else {
+                if (!keyInput.key || keyInput.key === "")
+                    continue; // Invalid trigger, skip
+                configuredMainKey = keyInput.key;
+                ctrlKeyConfig = keyInput.ctrlKey;
+                altKeyConfig = keyInput.altKey;
+                shiftKeyConfig = keyInput.shiftKey;
+                metaKeyConfig = keyInput.metaKey;
+            }
+            const keyMatch = compareKey(event.key, configuredMainKey);
+            if (!keyMatch)
+                continue;
+            const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
+            const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
+            const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
+            const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
+            if (ctrlMatch && altMatch && shiftMatch && metaMatch) {
+                return true;
+            }
+        }
+        return false;
+    }
+    filterByContext(source$, context) {
+        return source$.pipe(withLatestFrom(this.activeContext$), filter(([/* event */ , activeCtx]) => {
+            // If context is explicitly null, only match when active context is also null.
+            if (context === null) {
+                return activeCtx === null;
+            }
+            // If context is undefined (truly global), it can run alongside a specific context.
+            // If context is a string, it must match the active context.
+            return context === undefined || context === activeCtx;
+        }), map(([event, /* _activeCtx */]) => event));
+    }
+    _registerShortcut(config, subscription, type, detailsForLog) {
+        const existingShortcut = this.activeShortcuts.get(config.id);
+        if (existingShortcut) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${config.id}" already exists. It will be overwritten.`);
+            existingShortcut.subscription.unsubscribe();
+        }
+        this.activeShortcuts.set(config.id, { id: config.id, config, subscription });
+        if (this.debugMode) {
+            console.log(`${Hotkeys.LOG_PREFIX} ${type} shortcut "${config.id}" added. ${detailsForLog}, Context: ${config.context ?? "any"}`);
+        }
+        return config.id;
+    }
+    _parseKeyTrigger(keyInput, shortcutId) {
+        if (typeof keyInput === "string") {
+            if (keyInput === "") {
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid key (shorthand) in shortcut "${shortcutId}". Key string must not be empty.`);
+                return null;
+            }
+            return {
+                configuredMainKey: keyInput,
+                ctrlKeyConfig: false,
+                altKeyConfig: false,
+                shiftKeyConfig: false,
+                metaKeyConfig: false,
+                logDetails: `key: "${keyInput}" (no mods)`,
+            };
+        }
+        else {
+            if (!keyInput.key || typeof keyInput.key !== "string" || keyInput.key === "") {
+                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "key" property in shortcut "${shortcutId}". Key must be a non-empty string value from Keys.`);
+                return null;
+            }
+            const logDetails = `key: "${keyInput.key}"` +
+                (keyInput.ctrlKey !== undefined ? `, ctrl: ${keyInput.ctrlKey}` : "") +
+                (keyInput.altKey !== undefined ? `, alt: ${keyInput.altKey}` : "") +
+                (keyInput.shiftKey !== undefined ? `, shift: ${keyInput.shiftKey}` : "") +
+                (keyInput.metaKey !== undefined ? `, meta: ${keyInput.metaKey}` : "");
+            return {
+                configuredMainKey: keyInput.key,
+                ctrlKeyConfig: keyInput.ctrlKey,
+                altKeyConfig: keyInput.altKey,
+                shiftKeyConfig: keyInput.shiftKey,
+                metaKeyConfig: keyInput.metaKey,
+                logDetails,
+            };
+        }
+    }
+    /**
+     * Registers a key combination shortcut.
+     * @param config - Configuration object for the key combination.
+     * @param strict - If `true` and the shortcut has no context, it will only fire when no context is active. Defaults to `false`.
+     * @returns The ID of the registered shortcut, or `undefined` if invalid.
+     */
+    addCombination(config, strict = false) {
+        const { keys, callback, context, preventDefault = false, id } = config;
+        if (context && strict) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" has both a context and the 'strict' flag. The 'strict' flag will be ignored.`);
+        }
+        const keyTriggers = Array.isArray(keys) ? keys : [keys];
+        if (keyTriggers.length === 0) {
+            console.warn(`${Hotkeys.LOG_PREFIX} "keys" array for combination shortcut "${id}" is empty. Shortcut not added.`);
+            return undefined;
+        }
+        const observables = [];
+        const logParts = [];
+        // Determine the base stream based on the strict flag
+        const baseStream$ = (context == null && strict)
+            ? this.keydown$.pipe(withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
+            : this.keydown$;
+        for (const keyInput of keyTriggers) {
+            const parsedTrigger = this._parseKeyTrigger(keyInput, id);
+            if (!parsedTrigger)
+                return undefined;
+            const { configuredMainKey, ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig, logDetails } = parsedTrigger;
+            logParts.push(`{ ${logDetails} }`);
+            const stream = baseStream$.pipe(
+            // For non-strict shortcuts, filter by context here
+            filter(() => {
+                if (context == null && strict)
+                    return true; // Already filtered by baseStream$
+                return context === this.activeContext$.getValue();
+            }), filter(event => {
+                const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
+                const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
+                const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
+                const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
+                return ctrlMatch && altMatch && shiftMatch && metaMatch;
+            }), filter(event => compareKey(event.key, configuredMainKey)), 
+            // Original priority filter for non-strict global shortcuts
+            filter(event => {
+                if (context != null || strict)
+                    return true;
+                const currentSpecificContext = this.activeContext$.getValue();
+                if (currentSpecificContext == null)
+                    return true;
+                for (const [, otherAS] of this.activeShortcuts) {
+                    if (otherAS.config.id !== config.id &&
+                        'keys' in otherAS.config &&
+                        otherAS.config.context === currentSpecificContext &&
+                        this._shortcutMatchesEvent(otherAS.config, event)) {
+                        if (this.debugMode) {
+                            console.log(`${Hotkeys.LOG_PREFIX} Global shortcut "${config.id}" (key: "${event.key}") suppressed by specific context shortcut "${otherAS.config.id}".`);
+                        }
+                        return false;
+                    }
+                }
+                return true;
+            }));
+            observables.push(stream);
+        }
+        if (observables.length === 0)
+            return undefined;
+        const finalShortcut$ = merge(...observables);
+        const overallLogDetails = `Triggers: [ ${logParts.join(", ")} ]`;
+        const subscription = finalShortcut$.pipe(tap(event => {
+            if (this.debugMode) {
+                console.log(`${Hotkeys.LOG_PREFIX} Combination "${id}" triggered by key "${event.key}".`);
+            }
+            if (preventDefault)
+                event.preventDefault();
+        }), catchError(err => {
+            console.error(`${Hotkeys.LOG_PREFIX} Error in stream for shortcut "${id}":`, err);
+            return EMPTY;
+        })).subscribe(event => {
+            try {
+                callback(event);
+            }
+            catch (e) {
+                console.error(`${Hotkeys.LOG_PREFIX} Error in callback for combination shortcut "${id}":`, e);
+            }
+        });
+        return this._registerShortcut(config, subscription, ShortcutTypes.Combination, overallLogDetails);
+    }
+    /**
+     * Registers a key sequence shortcut.
+     * @param config - Configuration object for the key sequence.
+     * @param strict - If `true` and the shortcut has no context, it will only fire when no context is active. Defaults to `false`.
+     * @returns The ID of the registered shortcut, or `undefined` if invalid.
+     */
+    addSequence(config, strict = false) {
+        const { sequence, callback, context, preventDefault = false, id, sequenceTimeoutMs } = config;
+        if (!Array.isArray(sequence) || sequence.length === 0) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Sequence for shortcut "${id}" is empty or invalid. Shortcut not added.`);
+            return undefined;
+        }
+        if (sequence.some(key => typeof key !== "string" || key === "")) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Invalid key in sequence for shortcut "${id}". All keys must be non-empty string values from Keys. Shortcut not added.`);
+            return undefined;
+        }
+        if (context && strict) {
+            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" has both a context and the 'strict' flag. The 'strict' flag will be ignored.`);
+        }
+        const sequenceLength = sequence.length;
+        const baseKeydownStream$ = (context == null && strict)
+            ? this.keydown$.pipe(withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
+            : this.filterByContext(this.keydown$, context);
+        let shortcut$;
+        if (sequenceTimeoutMs && sequenceTimeoutMs > 0) {
+            shortcut$ = baseKeydownStream$.pipe(scan((acc, event) => {
+                // (Scan logic remains the same as original)
+                let { matchedEvents, lastEventTime } = acc;
+                const currentTime = performance.now();
+                if (acc.emitState === EmitStates.Emit)
+                    matchedEvents = [];
+                if (matchedEvents.length > 0 && (currentTime - lastEventTime > sequenceTimeoutMs))
+                    matchedEvents = [];
+                if (compareKey(event.key, sequence[matchedEvents.length])) {
+                    const newMatched = [...matchedEvents, event];
+                    if (newMatched.length === sequenceLength)
+                        return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.Emit };
+                    return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.InProgress };
+                }
+                if (compareKey(event.key, sequence[0]))
+                    return { matchedEvents: [event], lastEventTime: currentTime, emitState: EmitStates.InProgress };
+                return { matchedEvents: [], lastEventTime: 0, emitState: EmitStates.Ignore };
+            }, { matchedEvents: [], lastEventTime: 0, emitState: EmitStates.Ignore }), filter(state => state.emitState === EmitStates.Emit), map(state => state.matchedEvents));
+        }
+        else {
+            shortcut$ = baseKeydownStream$.pipe(bufferCount(sequenceLength, 1), filter((events) => events.every((event, index) => compareKey(event.key, sequence[index]))));
+        }
+        const finalShortcutWithPriority$ = shortcut$.pipe(filter(() => {
+            if (context != null || strict)
+                return true;
+            const currentSpecificContext = this.activeContext$.getValue();
+            if (currentSpecificContext == null)
+                return true;
+            for (const [, otherAS] of this.activeShortcuts) {
+                if (otherAS.config.id !== config.id &&
+                    "sequence" in otherAS.config &&
+                    otherAS.config.context === currentSpecificContext &&
+                    this._areSequencesIdentical(config.sequence, otherAS.config.sequence)) {
+                    if (this.debugMode) {
+                        console.log(`${Hotkeys.LOG_PREFIX} Global sequence shortcut "${config.id}" suppressed by identical specific-context shortcut "${otherAS.config.id}".`);
+                    }
+                    return false;
+                }
+            }
+            return true;
+        }), tap(events => {
+            if (preventDefault && events.length > 0)
+                events[events.length - 1].preventDefault();
+        }), catchError(err => {
+            console.error(`${Hotkeys.LOG_PREFIX} Error in sequence stream for shortcut "${id}":`, err);
+            return EMPTY;
+        }));
+        const subscription = finalShortcutWithPriority$.subscribe((events) => {
+            try {
+                if (events.length > 0)
+                    callback(events[events.length - 1]);
+            }
+            catch (e) {
+                console.error(`${Hotkeys.LOG_PREFIX} Error in user callback for sequence shortcut "${id}":`, e);
+            }
+        });
+        const logDetails = `Sequence: ${sequence.join(" -> ")}`;
+        return this._registerShortcut(config, subscription, ShortcutTypes.Sequence, logDetails);
+    }
+    /**
+     * Removes a registered shortcut by its ID.
+     */
+    remove(id) {
+        const shortcut = this.activeShortcuts.get(id);
+        if (shortcut) {
+            shortcut.subscription.unsubscribe();
+            this.activeShortcuts.delete(id);
+            if (this.debugMode)
+                console.log(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" removed.`);
+            return true;
+        }
+        console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${id}" not found for removal.`);
+        return false;
+    }
+    /**
+     * Retrieves a list of all currently active (registered) shortcut configurations.
+     */
+    getActiveShortcuts() {
+        const shortcuts = [];
+        for (const [id, activeShortcut] of this.activeShortcuts.entries()) {
+            shortcuts.push({
+                id,
+                description: activeShortcut.config.description,
+                context: activeShortcut.config.context,
+                type: ("sequence" in activeShortcut.config) ? ShortcutTypes.Sequence : ShortcutTypes.Combination
+            });
+        }
+        return shortcuts;
+    }
+    /**
+     * Cleans up all active subscriptions and resources used by the Hotkeys instance.
+     */
+    destroy() {
+        if (this.debugMode)
+            console.log(`${Hotkeys.LOG_PREFIX} Destroying library instance and unsubscribing all shortcuts.`);
+        this.activeShortcuts.forEach(shortcut => shortcut.subscription.unsubscribe());
+        this.activeShortcuts.clear();
+        this.activeContext$.complete();
+        if (this.debugMode)
+            console.log(`${Hotkeys.LOG_PREFIX} Library destroyed.`);
+    }
+}

package/dist/tttt.d.ts

@@ -0,0 +1,67 @@
+import { Subscription, Observable } from "rxjs";
+import { type StandardKey } from "./keys.js";
+export declare enum ShortcutTypes {
+    Combination = "combination",
+    Sequence = "sequence"
+}
+interface ShortcutConfigBase {
+    id: string;
+    callback: (event: KeyboardEvent) => void;
+    context?: string | null;
+    preventDefault?: boolean;
+    description?: string;
+}
+type KeyCombinationTrigger = {
+    key: StandardKey;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+} | StandardKey;
+export interface KeyCombinationConfig extends ShortcutConfigBase {
+    keys: KeyCombinationTrigger | KeyCombinationTrigger[];
+}
+export interface KeySequenceConfig extends ShortcutConfigBase {
+    sequence: StandardKey[];
+    sequenceTimeoutMs?: number;
+}
+type ShortcutConfig = KeyCombinationConfig | KeySequenceConfig;
+export interface ActiveShortcut {
+    id: string;
+    config: ShortcutConfig;
+    subscription: Subscription;
+}
+export declare class Hotkeys {
+    private static readonly KEYDOWN_EVENT;
+    private static readonly LOG_PREFIX;
+    private keydown$;
+    private activeContext$;
+    private activeShortcuts;
+    private debugMode;
+    constructor(initialContext?: string | null, debugMode?: boolean);
+    setContext(contextName: string | null): boolean;
+    getContext(): string | null;
+    setDebugMode(enable: boolean): void;
+    hasShortcut(id: string): boolean;
+    get onContextChange$(): Observable<string | null>;
+    private _areSequencesIdentical;
+    private _shortcutMatchesEvent;
+    /**
+     * Pre-filters a stream of keyboard events based on context and strictness rules.
+     */
+    private filterByContext;
+    private _registerShortcut;
+    private _parseKeyTrigger;
+    addCombination(config: KeyCombinationConfig, strict?: boolean): string | undefined;
+    addSequence(config: KeySequenceConfig, strict?: boolean): string | undefined;
+    remove(id: string): boolean;
+    getActiveShortcuts(): {
+        id: string;
+        description?: string;
+        context?: string | null;
+        type: ShortcutTypes;
+    }[];
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=tttt.d.ts.map

package/dist/tttt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tttt.d.ts","sourceRoot":"","sources":["../src/tttt.ts"],"names":[],"mappings":"AAAA,OAAO,EACyB,YAAY,EAAE,UAAU,EAEvD,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAI7C,oBAAY,aAAa;IACrB,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;CACxB;AAcD,UAAU,kBAAkB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,KAAK,qBAAqB,GAAG;IACzB,GAAG,EAAE,WAAW,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,WAAW,CAAC;AAGhB,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC5D,IAAI,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,CAAC;CACzD;AAED,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IACzD,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,KAAK,cAAc,GAAG,oBAAoB,GAAG,iBAAiB,CAAC;AAE/D,MAAM,WAAW,cAAc;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,cAAc,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC9B;AASD,qBAAa,OAAO;IAChB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAa;IAClD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAc;IAEhD,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,eAAe,CAA8B;IACrD,OAAO,CAAC,SAAS,CAAU;gBAEf,cAAc,GAAE,MAAM,GAAG,IAAW,EAAE,SAAS,GAAE,OAAe;IAarE,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO;IAY/C,UAAU,IAAI,MAAM,GAAG,IAAI;IAI3B,YAAY,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAMnC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAIvC,IAAW,gBAAgB,IAAI,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC,CAEvD;IAED,OAAO,CAAC,sBAAsB;IAK9B,OAAO,CAAC,qBAAqB;IAsB7B;;OAEG;IACH,OAAO,CAAC,eAAe;IAoBvB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,gBAAgB;IA6BjB,cAAc,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,UAAQ,GAAG,MAAM,GAAG,SAAS;IA8EhF,WAAW,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,UAAQ,GAAG,MAAM,GAAG,SAAS;IAmE1E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAU3B,kBAAkB,IAAI;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,IAAI,EAAE,aAAa,CAAA;KAAC,EAAE;IASxG,OAAO,IAAI,IAAI;CAKzB"}