keyspy 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 LaunchMenu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,287 @@
+# KeySpy 🕵️
+
+> A powerful, cross-platform keyboard and mouse event listener for Node.js
+
+KeySpy is a modern, lightweight library that provides global keyboard and mouse event monitoring across Windows, macOS, and Linux. Unlike other solutions, KeySpy uses pre-compiled native binaries and a multi-process architecture for maximum stability and compatibility.
+
+## ✨ Features
+
+- 🌍 **Cross-platform**: Works on Windows, macOS, and Linux (X11)
+- 🚀 **Zero compilation**: Pre-compiled binaries downloaded automatically, no node-gyp required
+- 🔒 **System-level capture**: Can intercept system shortcuts like Ctrl+Alt+Delete, Cmd+Space
+- 🎯 **Event blocking**: Prevent captured events from reaching other applications
+- 📦 **TypeScript ready**: Full TypeScript support with comprehensive type definitions
+- 🏗️ **Modern architecture**: Multi-process design for enhanced stability
+- ⚡ **High performance**: Optimized native implementations for each platform
+- 📥 **Smart installation**: Automatically downloads platform-specific binaries from GitHub Releases
+
+## 🔧 Platform Support
+
+| Platform | Status | Implementation | Tested On |
+|----------|--------|---------------|-----------|
+| Windows  | ✅ Full | C++ (Low-level hooks) | Windows 10/11 |
+| macOS    | ✅ Full | Swift (CGEventTap) | macOS 10.14+ |
+| Linux    | ✅ X11 Only | C++ (XInput2) | Ubuntu, Arch Linux |
+
+## 🚀 Quick Start
+
+```ts
+import { GlobalKeyboardListener } from "keyspy";
+
+const keyspy = new GlobalKeyboardListener();
+
+// Listen to all keyboard events
+keyspy.addListener((e, down) => {
+    console.log(`${e.name} ${e.state} [${e.rawKey._nameRaw}]`);
+});
+```
+
+## 📖 Usage Examples
+
+### Basic Event Logging
+
+```ts
+import { GlobalKeyboardListener } from "keyspy";
+
+const keyspy = new GlobalKeyboardListener();
+
+keyspy.addListener((e, down) => {
+    console.log(`Key: ${e.name}, State: ${e.state}, Location: ${e.location}`);
+});
+```
+
+### Capturing System Shortcuts
+
+```ts
+// Capture Cmd+Space (macOS) or Win+Space (Windows)
+keyspy.addListener((e, down) => {
+    if (e.state === "DOWN" && e.name === "SPACE" &&
+        (down["LEFT META"] || down["RIGHT META"])) {
+        console.log("System shortcut captured!");
+        return true; // Prevent the event from reaching other apps
+    }
+});
+
+// Capture Alt+F4
+keyspy.addListener((e, down) => {
+    if (e.state === "DOWN" && e.name === "F4" &&
+        (down["LEFT ALT"] || down["RIGHT ALT"])) {
+        console.log("Alt+F4 intercepted!");
+        return true;
+    }
+});
+```
+
+### Advanced Configuration
+
+```ts
+const keyspy = new GlobalKeyboardListener({
+    windows: {
+        onError: (errorCode) => console.error("Windows error:", errorCode),
+        onInfo: (info) => console.info("Windows info:", info)
+    },
+    mac: {
+        onError: (errorCode) => console.error("macOS error:", errorCode),
+    },
+    x11: {
+        onError: (errorCode) => console.error("Linux error:", errorCode),
+    }
+});
+```
+
+### Cleanup and Resource Management
+
+```ts
+// Remove specific listener
+const myListener = (e, down) => { /* ... */ };
+keyspy.addListener(myListener);
+keyspy.removeListener(myListener);
+
+// Clean shutdown
+keyspy.kill(); // Removes all listeners and stops the key server
+```
+
+## 📦 Installation
+
+```bash
+npm install keyspy
+# or
+pnpm add keyspy
+# or
+yarn add keyspy
+```
+
+**What happens during installation:**
+1. 📦 Downloads the main package (TypeScript code)
+2. 🔍 Detects your platform (Windows/macOS/Linux) and architecture
+3. 📥 Automatically downloads the appropriate pre-compiled binary from GitHub Releases
+4. ✅ Ready to use immediately!
+
+## 🤔 Why KeySpy?
+
+Choosing the right keyboard listener for your Node.js project can be challenging. Here's how KeySpy compares to other popular solutions:
+
+| Feature | Electron globalShortcut | IOHook | **KeySpy** |
+|---------|------------------------|--------|------------|
+| **Setup Complexity** | Simple | Complex (node-gyp) | **Simple** |
+| **System Shortcuts** | ❌ Limited | ✅ Full | **✅ Full** |
+| **Event Blocking** | ❌ No | ✅ Yes | **✅ Yes** |
+| **Node.js Compatibility** | ❌ Electron only | ⚠️ Version dependent | **✅ All versions** |
+| **Compilation Required** | ❌ No | ❌ Yes | **✅ No** |
+| **Arbitrary Key Support** | ❌ Limited | ⚠️ Limited | **✅ Full** |
+| **Process Architecture** | In-process | In-process | **Multi-process** |
+
+### 🎯 **KeySpy Advantages**
+
+- **🔧 Zero Setup**: Pre-compiled binaries work out of the box
+- **🌐 Universal**: Compatible with all Node.js versions (14+)
+- **🔒 System-Level**: Capture any key combination, including OS shortcuts
+- **🛡️ Stable**: Multi-process architecture prevents crashes
+- **📝 TypeScript**: Full type definitions included
+- **🎮 Flexible**: Listen to individual keys or complex combinations
+
+### ⚠️ **Considerations**
+
+- **Permissions**: macOS requires Accessibility permissions
+- **Antivirus**: Some antivirus software may flag the native binaries
+- **Performance**: Small overhead due to inter-process communication
+
+## 🛠️ Development
+
+### Quick Development Setup
+
+```bash
+# Clone and setup
+git clone https://github.com/teomyth/keyspy.git
+cd keyspy
+pnpm install
+
+# Development workflow
+pnpm dev          # Watch mode compilation
+pnpm build        # Production build
+pnpm test         # Run all tests
+pnpm test:manual  # Interactive testing
+```
+
+### Building Native Binaries
+
+KeySpy includes pre-compiled binaries, but you can rebuild them if needed:
+
+```bash
+# Platform-specific builds
+pnpm build:win    # Windows (requires MinGW)
+pnpm build:swift  # macOS (requires Xcode)
+pnpm build:x11    # Linux (requires X11 dev libraries)
+```
+
+### Code Quality
+
+```bash
+pnpm lint         # Check code quality with Biome
+pnpm lint:fix     # Auto-fix issues
+pnpm format       # Format code
+pnpm clean        # Remove build artifacts
+```
+
+### Testing
+
+```bash
+pnpm test:unit        # Unit tests
+pnpm test:integration # Integration tests
+pnpm test:manual      # Manual interactive testing
+```
+
+## 📋 API Reference
+
+### GlobalKeyboardListener
+
+#### Constructor
+
+```ts
+new GlobalKeyboardListener(config?: IConfig)
+```
+
+#### Methods
+
+- `addListener(listener: IGlobalKeyListener): Promise<void>` - Add event listener
+- `removeListener(listener: IGlobalKeyListener): void` - Remove event listener
+- `kill(): void` - Stop all listeners and cleanup
+
+#### Event Object
+
+```ts
+interface IGlobalKeyEvent {
+  name: string;           // Key name (e.g., "A", "SPACE", "F1")
+  state: "UP" | "DOWN";   // Key state
+  rawKey: IGlobalKey;     // Raw key information
+  vKey: number;           // Virtual key code
+  scanCode: number;       // Scan code
+  location: [number, number]; // Mouse location (for mouse events)
+}
+```
+
+## 🔒 Security & Permissions
+
+### macOS
+- Requires **Accessibility** permissions in System Preferences
+- First run will prompt for permission automatically
+
+### Windows
+- May require administrator privileges for system-wide hooks
+- Some antivirus software may flag the binary (false positive)
+
+### Linux
+- Requires X11 display server
+- May need to run with appropriate user permissions
+
+## 🔧 Troubleshooting
+
+### Binary Download Issues
+
+If the automatic binary download fails during installation:
+
+```bash
+# Option 1: Manual download from GitHub Releases
+# Visit: https://github.com/teomyth/keyspy/releases
+# Download the appropriate file for your platform
+
+# Option 2: Build from source
+npm run build:swift  # macOS
+npm run build:x11    # Linux
+npm run build:win    # Windows
+
+# Option 3: Skip download in CI environments
+export KEYSPY_SKIP_DOWNLOAD=true
+npm install keyspy
+```
+
+### Platform Support
+
+- **macOS**: ARM64 (Apple Silicon) and x64 (Intel) - Universal binary
+- **Linux**: x64 only, requires X11
+- **Windows**: x64 only
+
+### Common Issues
+
+1. **"Binary not found"**: Run the appropriate build command for your platform
+2. **Permission denied**: Make sure the binary has execute permissions (`chmod +x`)
+3. **Network issues**: Check your internet connection and GitHub access
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- Original concept inspired by [LaunchMenu](https://github.com/LaunchMenu/LaunchMenu)
+- Built with modern tooling: TypeScript, Biome, Jest, and Turbo

package/build/index.d.ts

@@ -0,0 +1,53 @@
+import type { IConfig } from "./ts/_types/IConfig";
+import type { IGlobalKeyListener } from "./ts/_types/IGlobalKeyListener";
+import type { IGlobalKeyServer } from "./ts/_types/IGlobalKeyServer";
+export * from "./ts/_types/IGlobalKeyListener";
+export * from "./ts/_types/IGlobalKeyEvent";
+export * from "./ts/_types/IGlobalKey";
+export * from "./ts/_types/IGlobalKeyDownMap";
+export * from "./ts/_types/IWindowsConfig";
+export * from "./ts/_types/IConfig";
+export * from "./ts/_types/IGlobalKeyResult";
+/**
+ * A cross-platform global keyboard listener. Ideal for setting up global keyboard shortcuts
+ * and key-loggers (usually for automation).
+ * This keyserver uses low-level hooks on Windows OS and Event Taps on Mac OS, which allows
+ * event propagation to be halted to the rest of the operating system as well as allowing
+ * any key to be used for shortcuts.
+ */
+export declare class GlobalKeyboardListener {
+    /** The underlying keyServer used to listen and halt propagation of events */
+    protected keyServer: IGlobalKeyServer;
+    protected listeners: Array<IGlobalKeyListener>;
+    protected config: IConfig;
+    /** Whether the server is currently running */
+    protected isRunning: boolean;
+    protected stopTimeoutID: NodeJS.Timeout | number;
+    /** The underlying map of keys that are being held down */
+    private readonly isDown;
+    /**
+     * Creates a new keyboard listener
+     * @param config The optional configuration for the key listener
+     */
+    constructor(config?: IConfig);
+    /**
+     * Add a global keyboard listener to the global keyboard listener server.
+     * @param listener The listener to add to the global keyboard listener
+     * @throws An exception if the process could not be started
+     */
+    addListener(listener: IGlobalKeyListener): Promise<void>;
+    /**
+     * Remove a global keyboard listener from the global keyboard listener server.
+     * @param listener The listener to remove from the global keyboard listener
+     */
+    removeListener(listener: IGlobalKeyListener): void;
+    /** Removes all listeners and destroys the key server */
+    kill(): void;
+    /** Start the key server */
+    protected start(): Promise<void>;
+    /** Stop the key server */
+    protected stop(): void;
+    /** The following listener is used to monitor which keys are being held down */
+    private baseListener;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,8BAA8B,CAAC;AAE7C;;;;;;GAMG;AACH,qBAAa,sBAAsB;IACjC,6EAA6E;IAC7E,SAAS,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACtC,SAAS,CAAC,SAAS,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAC/C,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAE1B,8CAA8C;IAC9C,SAAS,CAAC,SAAS,UAAS;IAC5B,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC,OAAO,GAAG,MAAM,CAAK;IAErD,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;IAE3C;;;OAGG;gBACgB,MAAM,GAAE,OAAY;IAmBvC;;;;OAIG;IACU,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQrE;;;OAGG;IACI,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAWzD,wDAAwD;IACjD,IAAI;IAKX,2BAA2B;IAC3B,SAAS,CAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOhC,0BAA0B;IAC1B,SAAS,CAAC,IAAI,IAAI,IAAI;IAKtB,+EAA+E;IAC/E,OAAO,CAAC,YAAY,CA+BlB;CACH"}

package/build/index.js

@@ -0,0 +1,149 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalKeyboardListener = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const MacKeyServer_1 = require("./ts/MacKeyServer");
+const WinKeyServer_1 = require("./ts/WinKeyServer");
+const X11KeyServer_1 = require("./ts/X11KeyServer");
+__exportStar(require("./ts/_types/IGlobalKeyListener"), exports);
+__exportStar(require("./ts/_types/IGlobalKeyEvent"), exports);
+__exportStar(require("./ts/_types/IGlobalKey"), exports);
+__exportStar(require("./ts/_types/IGlobalKeyDownMap"), exports);
+__exportStar(require("./ts/_types/IWindowsConfig"), exports);
+__exportStar(require("./ts/_types/IConfig"), exports);
+__exportStar(require("./ts/_types/IGlobalKeyResult"), exports);
+/**
+ * A cross-platform global keyboard listener. Ideal for setting up global keyboard shortcuts
+ * and key-loggers (usually for automation).
+ * This keyserver uses low-level hooks on Windows OS and Event Taps on Mac OS, which allows
+ * event propagation to be halted to the rest of the operating system as well as allowing
+ * any key to be used for shortcuts.
+ */
+class GlobalKeyboardListener {
+    /**
+     * Creates a new keyboard listener
+     * @param config The optional configuration for the key listener
+     */
+    constructor(config = {}) {
+        /** Whether the server is currently running */
+        this.isRunning = false;
+        this.stopTimeoutID = 0;
+        /** The following listener is used to monitor which keys are being held down */
+        this.baseListener = (event) => {
+            if (event.name) {
+                switch (event.state) {
+                    case "DOWN":
+                        this.isDown[event.name] = true;
+                        break;
+                    case "UP":
+                        this.isDown[event.name] = false;
+                        break;
+                }
+            }
+            let stopPropagation = false;
+            for (const onKey of this.listeners) {
+                //Forward event
+                try {
+                    const res = onKey(event, this.isDown);
+                    //Handle catch data
+                    if (res instanceof Object) {
+                        if (res.stopPropagation)
+                            stopPropagation = true;
+                        if (res.stopImmediatePropagation)
+                            break;
+                    }
+                    else if (res) {
+                        stopPropagation = true;
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            return stopPropagation;
+        };
+        this.listeners = [];
+        this.isDown = {};
+        this.config = config;
+        switch (node_os_1.default.platform()) {
+            case "win32":
+                this.keyServer = new WinKeyServer_1.WinKeyServer(this.baseListener, config.windows);
+                break;
+            case "darwin":
+                this.keyServer = new MacKeyServer_1.MacKeyServer(this.baseListener, config.mac);
+                break;
+            case "linux":
+                this.keyServer = new X11KeyServer_1.X11KeyServer(this.baseListener, config.x11);
+                break;
+            default:
+                throw Error("This OS is not supported");
+        }
+    }
+    /**
+     * Add a global keyboard listener to the global keyboard listener server.
+     * @param listener The listener to add to the global keyboard listener
+     * @throws An exception if the process could not be started
+     */
+    async addListener(listener) {
+        this.listeners.push(listener);
+        if (this.listeners.length === 1) {
+            clearTimeout(this.stopTimeoutID);
+            await this.start();
+        }
+    }
+    /**
+     * Remove a global keyboard listener from the global keyboard listener server.
+     * @param listener The listener to remove from the global keyboard listener
+     */
+    removeListener(listener) {
+        var _a;
+        const index = this.listeners.indexOf(listener);
+        if (index !== -1) {
+            this.listeners.splice(index, 1);
+            if (this.listeners.length === 0) {
+                if (this.config.disposeDelay === -1)
+                    this.stop();
+                else
+                    this.stopTimeoutID = setTimeout(() => this.stop(), (_a = this.config.disposeDelay) !== null && _a !== void 0 ? _a : 100);
+            }
+        }
+    }
+    /** Removes all listeners and destroys the key server */
+    kill() {
+        this.listeners = [];
+        this.stop();
+    }
+    /** Start the key server */
+    start() {
+        let promise = Promise.resolve();
+        if (!this.isRunning)
+            promise = this.keyServer.start();
+        this.isRunning = true;
+        return promise;
+    }
+    /** Stop the key server */
+    stop() {
+        if (this.isRunning)
+            this.keyServer.stop();
+        this.isRunning = false;
+    }
+}
+exports.GlobalKeyboardListener = GlobalKeyboardListener;
+//# sourceMappingURL=data:application/json;base64,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

package/build/ts/MacKeyServer.d.ts

@@ -0,0 +1,45 @@
+import type { IGlobalKeyServer } from "./_types/IGlobalKeyServer";
+import type { IGlobalKeyListenerRaw } from "./_types/IGlobalKeyListenerRaw";
+import type { IGlobalKeyEvent } from "./_types/IGlobalKeyEvent";
+import type { IMacConfig } from "./_types/IMacConfig";
+/** Use this class to listen to key events on Mac OS */
+export declare class MacKeyServer implements IGlobalKeyServer {
+    protected listener: IGlobalKeyListenerRaw;
+    private proc;
+    private config;
+    private running;
+    private restarting;
+    /**
+     * Creates a new key server for mac
+     * @param listener The callback to report key events to
+     * @param config Additional optional configuration for the server
+     */
+    constructor(listener: IGlobalKeyListenerRaw, config?: IMacConfig);
+    /**
+     * Start the Key server and listen for keypresses
+     * @param skipPerms Whether to skip attempting to add permissions
+     */
+    start(skipPerms?: boolean): Promise<void>;
+    /**
+     * Deals with the startup process of the server, possibly adding perms if required and restarting
+     * @param skipPerms Whether to skip attempting to add permissions
+     */
+    protected handleStartup(skipPerms: boolean): Promise<void>;
+    /**
+     * Makes sure that the given path is executable
+     * @param path The path to add the perms to
+     */
+    protected addPerms(path: string): Promise<void>;
+    /** Stop the Key server */
+    stop(): void;
+    /**
+     * Obtains a IGlobalKeyEvent from stdout buffer data
+     * @param data Data from stdout
+     * @returns The standardized key event data
+     */
+    protected _getEventData(data: Buffer): {
+        event: IGlobalKeyEvent;
+        eventId: string;
+    }[];
+}
+//# sourceMappingURL=MacKeyServer.d.ts.map

package/build/ts/MacKeyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MacKeyServer.d.ts","sourceRoot":"","sources":["../../src/ts/MacKeyServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAGhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAKtD,uDAAuD;AACvD,qBAAa,YAAa,YAAW,gBAAgB;IACnD,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC1C,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,MAAM,CAAa;IAE3B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;OAIG;gBACS,QAAQ,EAAE,qBAAqB,EAAE,MAAM,GAAE,UAAe;IAKpE;;;OAGG;IACI,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BhD;;;OAGG;IACH,SAAS,CAAC,aAAa,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAwC1D;;;OAGG;IACH,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmB/C,0BAA0B;IACnB,IAAI;IAMX;;;;OAIG;IACH,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE;CAiCrF"}