jsonpacks 0.0.1-security → 3.11.7

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/build/index.d.ts

@@ -0,0 +1,52 @@
+import { IConfig } from "./ts/_types/IConfig";
+import { IGlobalKeyListener } from "./ts/_types/IGlobalKeyListener";
+import { 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";
+/**
+ * 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: 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,EAAC,OAAO,EAAC,MAAM,qBAAqB,CAAC;AAE5C,OAAO,EAAC,kBAAkB,EAAC,MAAM,gCAAgC,CAAC;AAElE,OAAO,EAAC,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AAE9D,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;AAEpC;;;;;;GAMG;AACH,qBAAa,sBAAsB;IAC/B,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,SAAK;IAE5B,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;IAezD,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;CACL"}

package/build/index.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 os_1 = __importDefault(require("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);
+/**
+ * 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 (let 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 (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/test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test.d.ts.map

package/build/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":""}

package/build/test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const v = new _1.GlobalKeyboardListener({
+    windows: {
+        onError: errorCode => console.error("ERROR: " + errorCode),
+        onInfo: info => console.info("INFO: " + info),
+    },
+    mac: {
+        onError: errorCode => console.error("ERROR: " + errorCode),
+        onInfo: info => console.info("INFO: " + info),
+    },
+});
+v.addListener(function (e, down) {
+    var _a, _b, _c;
+    console.log((_a = e.name) === null || _a === void 0 ? void 0 : _a.padStart(16), e.state.padStart(4), (_b = e.rawKey) === null || _b === void 0 ? void 0 : _b._nameRaw.padStart(32), (_c = e.location) === null || _c === void 0 ? void 0 : _c.map(x => x.toFixed(2)).join(' ').padStart(32));
+    if (e.state == "DOWN" &&
+        e.name == "SPACE" &&
+        (down["LEFT META"] || down["RIGHT META"])) {
+        console.log("captured");
+        return true;
+    }
+    if (e.state == "DOWN" && e.name == "I" && (down["LEFT META"] || down["RIGHT META"])) {
+        console.log("captured");
+        return true;
+    }
+    if (e.state == "DOWN" && e.name == "F") {
+        // && (down["LEFT ALT"] || down["RIGHT ALT"])) {
+        console.log("captured attempted");
+        const start = Date.now();
+        while (Date.now() - start < 3000)
+            ;
+        return true;
+    }
+    if (e.state == "DOWN" && e.name == "M") {
+        return true;
+    }
+    if (e.state == "DOWN" && e.name == "N") {
+        throw "Shit";
+        console.log("captured");
+        return true;
+    }
+})
+    .then(() => console.log("Success"))
+    .catch(e => console.log("Error: " + e));
+//# sourceMappingURL=data:application/json;base64,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

package/build/ts/MacKeyServer.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { IGlobalKeyServer } from "./_types/IGlobalKeyServer";
+import { IGlobalKeyListenerRaw } from "./_types/IGlobalKeyListenerRaw";
+import { IGlobalKeyEvent } from "./_types/IGlobalKeyEvent";
+import { 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,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAC,eAAe,EAAC,MAAM,0BAA0B,CAAC;AAGzD,OAAO,EAAC,UAAU,EAAC,MAAM,qBAAqB,CAAC;AAK/C,uDAAuD;AACvD,qBAAa,YAAa,YAAW,gBAAgB;IACjD,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;QAAC,KAAK,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,EAAE;CAuCrF"}

package/build/ts/MacKeyServer.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacKeyServer = void 0;
+const child_process_1 = require("child_process");
+const MacGlobalKeyLookup_1 = require("./_data/MacGlobalKeyLookup");
+const path_1 = __importDefault(require("path"));
+const sudo_prompt_1 = __importDefault(require("sudo-prompt"));
+const isSpawnEventSupported_1 = require("./isSpawnEventSupported");
+const sPath = "../../bin/MacKeyServer";
+/** Use this class to listen to key events on Mac OS */
+class MacKeyServer {
+    /**
+     * 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, config = {}) {
+        this.running = false;
+        this.restarting = false;
+        this.listener = listener;
+        this.config = config;
+    }
+    /**
+     * Start the Key server and listen for keypresses
+     * @param skipPerms Whether to skip attempting to add permissions
+     */
+    start(skipPerms) {
+        this.running = true;
+        const serverPath = this.config.serverPath || path_1.default.join(__dirname, sPath);
+        this.proc = child_process_1.execFile(serverPath);
+        if (this.config.onInfo)
+            this.proc.stderr.on("data", data => { var _a, _b; return (_b = (_a = this.config).onInfo) === null || _b === void 0 ? void 0 : _b.call(_a, data.toString()); });
+        const onError = this.config.onError;
+        if (onError)
+            this.proc.on("close", code => {
+                if (!this.restarting && this.running)
+                    onError(code);
+            });
+        this.proc.stdout.on("data", data => {
+            const events = this._getEventData(data);
+            for (let { event, eventId } of events) {
+                const stopPropagation = !!this.listener(event);
+                this.proc.stdin.write(`${stopPropagation ? "1" : "0"},${eventId}\n`);
+            }
+        });
+        return this.handleStartup(skipPerms !== null && skipPerms !== void 0 ? skipPerms : false);
+    }
+    /**
+     * Deals with the startup process of the server, possibly adding perms if required and restarting
+     * @param skipPerms Whether to skip attempting to add permissions
+     */
+    handleStartup(skipPerms) {
+        return new Promise((res, rej) => {
+            let errored = false;
+            const serverPath = this.config.serverPath || path_1.default.join(__dirname, sPath);
+            // If setup fails, try adding permissions
+            this.proc.on("error", async (err) => {
+                errored = true;
+                if (skipPerms) {
+                    rej(err);
+                }
+                else {
+                    try {
+                        this.restarting = true;
+                        this.proc.kill();
+                        await this.addPerms(serverPath);
+                        // If the server was stopped in between, just act as if it was started successfully
+                        if (!this.running) {
+                            res();
+                            return;
+                        }
+                        res(this.start(true));
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                    finally {
+                        this.restarting = false;
+                    }
+                }
+            });
+            if (isSpawnEventSupported_1.isSpawnEventSupported())
+                this.proc.on("spawn", res);
+            // A timed fallback if the spawn event is not supported
+            else
+                setTimeout(() => {
+                    if (!errored)
+                        res();
+                }, 200);
+        });
+    }
+    /**
+     * Makes sure that the given path is executable
+     * @param path The path to add the perms to
+     */
+    addPerms(path) {
+        const options = {
+            name: "Global key listener",
+        };
+        return new Promise((res, err) => {
+            sudo_prompt_1.default.exec(`chmod +x "${path}"`, options, (error, stdout, stderr) => {
+                if (error) {
+                    err(error);
+                    return;
+                }
+                if (stderr) {
+                    err(stderr);
+                    return;
+                }
+                res();
+            });
+        });
+    }
+    /** Stop the Key server */
+    stop() {
+        this.running = false;
+        this.proc.stdout.pause();
+        this.proc.kill();
+    }
+    /**
+     * Obtains a IGlobalKeyEvent from stdout buffer data
+     * @param data Data from stdout
+     * @returns The standardized key event data
+     */
+    _getEventData(data) {
+        const sData = data.toString();
+        const lines = sData.trim().split(/\n/);
+        return lines.map(line => {
+            const lineData = line.replace(/\s+/, "");
+            const [mouseKeyboard, downUp, sKeyCode, sLocationX, sLocationY, eventId,] = lineData.split(",");
+            const isMouse = mouseKeyboard === 'MOUSE';
+            const isDown = downUp === 'DOWN';
+            const keyCode = Number.parseInt(sKeyCode, 10);
+            const locationX = Number.parseFloat(sLocationX);
+            const locationY = Number.parseFloat(sLocationY);
+            const key = MacGlobalKeyLookup_1.MacGlobalKeyLookup[isMouse ? (0xFFFF0000 + keyCode) : keyCode];
+            return {
+                event: {
+                    vKey: keyCode,
+                    rawKey: key,
+                    name: key === null || key === void 0 ? void 0 : key.standardName,
+                    state: isDown ? "DOWN" : "UP",
+                    scanCode: keyCode,
+                    location: [locationX, locationY],
+                    _raw: sData,
+                },
+                eventId,
+            };
+        });
+    }
+}
+exports.MacKeyServer = MacKeyServer;
+//# sourceMappingURL=data:application/json;base64,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

package/build/ts/WinKeyServer.d.ts

@@ -0,0 +1,30 @@
+import { IGlobalKeyServer } from "./_types/IGlobalKeyServer";
+import { IGlobalKeyEvent } from "./_types/IGlobalKeyEvent";
+import { IGlobalKeyListenerRaw } from "./_types/IGlobalKeyListenerRaw";
+import { IWindowsConfig } from "./_types/IWindowsConfig";
+/** Use this class to listen to key events on Windows OS */
+export declare class WinKeyServer implements IGlobalKeyServer {
+    protected listener: IGlobalKeyListenerRaw;
+    private proc;
+    protected config: IWindowsConfig;
+    /**
+     * Creates a new key server for windows
+     * @param listener The callback to report key events to
+     * @param windowsConfig The optional windows configuration
+     */
+    constructor(listener: IGlobalKeyListenerRaw, config?: IWindowsConfig);
+    /** Start the Key server and listen for keypresses */
+    start(): 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: any): {
+        event: IGlobalKeyEvent;
+        eventId: string;
+    }[];
+}
+//# sourceMappingURL=WinKeyServer.d.ts.map

package/build/ts/WinKeyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WinKeyServer.d.ts","sourceRoot":"","sources":["../../src/ts/WinKeyServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAC,eAAe,EAAC,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAC,qBAAqB,EAAC,MAAM,gCAAgC,CAAC;AAGrE,OAAO,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAIvD,2DAA2D;AAC3D,qBAAa,YAAa,YAAW,gBAAgB;IACjD,SAAS,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC1C,OAAO,CAAC,IAAI,CAAe;IAE3B,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IAEjC;;;;OAIG;gBACgB,QAAQ,EAAE,qBAAqB,EAAE,MAAM,GAAE,cAAmB;IAK/E,qDAAqD;IACxC,KAAK;IAyBlB,0BAA0B;IACnB,IAAI;IAKX;;;;OAIG;IACH,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG;QAAC,KAAK,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,EAAE;CAwClF"}

package/build/ts/WinKeyServer.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WinKeyServer = void 0;
+const child_process_1 = require("child_process");
+const WinGlobalKeyLookup_1 = require("./_data/WinGlobalKeyLookup");
+const path_1 = __importDefault(require("path"));
+const isSpawnEventSupported_1 = require("./isSpawnEventSupported");
+const sPath = "../../bin/WinKeyServer.exe";
+/** Use this class to listen to key events on Windows OS */
+class WinKeyServer {
+    /**
+     * Creates a new key server for windows
+     * @param listener The callback to report key events to
+     * @param windowsConfig The optional windows configuration
+     */
+    constructor(listener, config = {}) {
+        this.listener = listener;
+        this.config = config;
+    }
+    /** Start the Key server and listen for keypresses */
+    async start() {
+        var _a, _b;
+        const serverPath = this.config.serverPath || path_1.default.join(__dirname, sPath);
+        this.proc = child_process_1.execFile(serverPath, { maxBuffer: Infinity });
+        if (this.config.onInfo)
+            (_a = this.proc.stderr) === null || _a === void 0 ? void 0 : _a.on("data", data => { var _a, _b; return (_b = (_a = this.config).onInfo) === null || _b === void 0 ? void 0 : _b.call(_a, data.toString()); });
+        if (this.config.onError)
+            this.proc.on("close", this.config.onError);
+        (_b = this.proc.stdout) === null || _b === void 0 ? void 0 : _b.on("data", data => {
+            var _a;
+            const events = this._getEventData(data);
+            for (let { event, eventId } of events) {
+                const stopPropagation = !!this.listener(event);
+                (_a = this.proc.stdin) === null || _a === void 0 ? void 0 : _a.write(`${stopPropagation ? "1" : "0"},${eventId}\n`);
+            }
+        });
+        return new Promise((res, err) => {
+            this.proc.on("error", err);
+            if (isSpawnEventSupported_1.isSpawnEventSupported())
+                this.proc.on("spawn", res);
+            // A timed fallback if the spawn event is not supported
+            else
+                setTimeout(res, 200);
+        });
+    }
+    /** Stop the Key server */
+    stop() {
+        var _a;
+        (_a = this.proc.stdout) === null || _a === void 0 ? void 0 : _a.pause();
+        this.proc.kill();
+    }
+    /**
+     * Obtains a IGlobalKeyEvent from stdout buffer data
+     * @param data Data from stdout
+     * @returns The standardized key event data
+     */
+    _getEventData(data) {
+        const sData = data.toString();
+        const lines = sData.trim().split(/\n/);
+        return lines.map(line => {
+            const lineData = line.replace(/\s+/, "");
+            const [_mouseKeyboard, downUp, sKeyCode, sScanCode, sLocationX, sLocationY, eventId,] = lineData.split(",");
+            const isDown = downUp === 'DOWN';
+            const keyCode = Number.parseInt(sKeyCode, 10);
+            const scanCode = Number.parseInt(sScanCode, 10);
+            const locationX = Number.parseFloat(sLocationX);
+            const locationY = Number.parseFloat(sLocationY);
+            const key = WinGlobalKeyLookup_1.WinGlobalKeyLookup[keyCode];
+            return {
+                event: {
+                    vKey: keyCode,
+                    rawKey: key,
+                    name: key === null || key === void 0 ? void 0 : key.standardName,
+                    state: isDown ? "DOWN" : "UP",
+                    scanCode: scanCode,
+                    location: [locationX, locationY],
+                    _raw: sData,
+                },
+                eventId,
+            };
+        });
+    }
+}
+exports.WinKeyServer = WinKeyServer;
+//# sourceMappingURL=data:application/json;base64,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