node-native-win-utils 2.1.4 → 2.2.0

package/README.md

@@ -1,17 +1,6 @@
 
 [![License][license-src]][license-href] 
-![Node-API v8 Badge](assets/Node-API%20v8%20Badge.svg)
-
-#### USDT TRC20 - TYAJ3K3MZraJhWimxxeCKcJ2SYABkVsrzi
-####  USDT TON - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7
-####  BTC - 1A3mNKFdWKXZ7Bcnez8LbWbYHgck1g4GeV
-####  NOT - UQDokuYZXr4OHvfslDqUoFYcp1_F8tcjQPk_TvqSSDk7SIa7
-
-  
-
-####  Will be very thankful for any support
-
-  
+![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
 
 # Node Native Win Utils
 

package/dist/index.d.mts

@@ -75,15 +75,28 @@ export type Color = [r: number, g: number, b: number];
 export type ROI = [x: number, y: number, width: number, height: number];
 export type Imread = (path: string) => ImageData;
 export type Imwrite = (image: ImageData) => Buffer;
+export type StartMouseListener = (callback: (data: {
+    x: number;
+    y: number;
+    type: string;
+}) => void) => void;
+export type StopMouseListener = (error: {
+    success: boolean;
+    error?: string;
+    errorCode?: number;
+}) => void;
 export type MatchTemplate = (image: ImageData, template: ImageData, method?: number | null, mask?: ImageData) => MatchData;
 export type Blur = (image: ImageData, sizeX: number, sizeY: number) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
 export type EqualizeHist = (image: ImageData) => ImageData;
+export type ColorBound = [number, number, number];
+export type DarkenColor = (image: ImageData, lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) => ImageData;
 export type DrawRectangle = (image: ImageData, start: Point, end: Point, rgb: Color, thickness: number) => ImageData;
 export type GetRegion = (image: ImageData, region: ROI) => ImageData;
 export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
 export type CaptureScreenAsync = () => Promise<Buffer>;
-declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition;
+export type BringWindowToFront = (windowName: string) => boolean;
+declare const getWindowData: GetWindowData, captureWindowN: CaptureWindow, captureScreenAsync: CaptureScreenAsync, mouseMove: MouseMove, mouseClick: MouseClick, mouseDrag: MouseDrag, typeString: TypeString, textRecognition: TextRecognition, bringWindowToFront: BringWindowToFront, startMouseListener: StartMouseListener, stopMouseListener: StopMouseListener;
 declare const rawPressKey: PressKey;
 /**
  * Captures a window and saves it to a file.
@@ -250,6 +263,8 @@ declare class OpenCV {
       * @returns A new OpenCV instance with the equalized image data.
       */
     equalizeHist(): OpenCV;
+    rgbToHsv(rgb: ColorBound): number[][];
+    darkenColor(lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number): OpenCV;
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.
@@ -272,4 +287,4 @@ declare class OpenCV {
     imwrite(path: string): void;
 }
 declare function keyPress(keyCode: number, repeat?: number): Promise<boolean>;
-export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };
+export { getWindowData, bringWindowToFront, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, startMouseListener, stopMouseListener, KeyboardListener, OpenCV };

package/dist/index.mjs

@@ -8,7 +8,7 @@ const nodeGypBuild = __require("node-gyp-build");
 import { keyCodes, KeyCodeHelper } from "./keyCodes.mjs";
 import { __dirnameLocal } from "./dirnameLocal.mjs";
 const bindings = nodeGypBuild(path.resolve(__dirnameLocal, ".."));
-const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist } = bindings;
+const { setKeyDownCallback, setKeyUpCallback, unsetKeyDownCallback, unsetKeyUpCallback, getWindowData, captureWindowN, captureScreenAsync, mouseMove, mouseClick, mouseDrag, typeString, pressKey, imread, imwrite, matchTemplate, blur, bgrToGray, drawRectangle, getRegion, textRecognition, equalizeHist, darkenColor, bringWindowToFront, startMouseListener, stopMouseListener } = bindings;
 const rawPressKey = pressKey;
 /**
  * Captures a window and saves it to a file.
@@ -184,6 +184,38 @@ class OpenCV {
     equalizeHist() {
         return new OpenCV(equalizeHist(this.imageData));
     }
+    rgbToHsv(rgb) {
+        const r_norm = rgb[0] / 255;
+        const g_norm = rgb[1] / 255;
+        const b_norm = rgb[2] / 255;
+        const Cmax = Math.max(r_norm, g_norm, b_norm);
+        const Cmin = Math.min(r_norm, g_norm, b_norm);
+        const delta = Cmax - Cmin;
+        let Hue = 0;
+        if (delta !== 0) {
+            switch (Cmax) {
+                case r_norm:
+                    Hue = 60 * (((g_norm - b_norm) / delta) % 6);
+                    break;
+                case g_norm:
+                    Hue = 60 * (((b_norm - r_norm) / delta) + 2);
+                    break;
+                case b_norm:
+                    Hue = 60 * (((r_norm - g_norm) / delta) + 4);
+                    break;
+            }
+        }
+        let Saturation = 0.0 * 100;
+        if (Cmax !== 0)
+            Saturation = (delta / Cmax) * 100;
+        let Value = Cmax * 100;
+        return [
+            [Hue, Saturation, Value]
+        ];
+    }
+    darkenColor(lowerBound, upperBound, darkenFactor) {
+        return new OpenCV(darkenColor(this.imageData, lowerBound, upperBound, darkenFactor));
+    }
     /**
      * Draws a rectangle on the image.
      * @param start - The starting point of the rectangle.
@@ -230,4 +262,4 @@ function keyPress(keyCode, repeat) {
         return resolve(true);
     });
 }
-export { getWindowData, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, KeyboardListener, OpenCV };
+export { getWindowData, bringWindowToFront, captureWindow, captureWindowN, mouseMove, mouseClick, mouseDrag, typeString, keyPress, rawPressKey, KeyCodeHelper, textRecognition, captureScreenToFile, captureScreenAsync, startMouseListener, stopMouseListener, KeyboardListener, OpenCV };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-native-win-utils",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "author": "Andrew K.",
   "license": "MIT",
   "repository": "https://github.com/T-Rumibul/node-native-win-utils.git",
@@ -43,18 +43,13 @@
     "test": "tap run "
   },
   "dependencies": {
-    "node-addon-api": "^8.3.1",
-    "node-gyp": "^11.1.0",
+    "node-addon-api": "^8.6.0",
+    "node-gyp": "^12.2.0",
     "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
-    "@types/node": "^20.2.5",
-    "node-api-headers": "^1.5.0",
-    "tap": "^21.1.0"
-  },
-  "tap": {
-    "plugin": [
-      "@tapjs/sinon"
-    ]
+    "@types/node": "^25.3.5",
+    "node-api-headers": "^1.8.0",
+    "tap": "^21.6.2"
   }
 }

package/src/cpp/getWindowData.cpp

@@ -42,5 +42,78 @@ Napi::Value GetWindowData(const Napi::CallbackInfo &info)
     result.Set("x", Napi::Number::New(env, x));
     result.Set("y", Napi::Number::New(env, y));
 
+    return result;
+}
+
+Napi::Value BringWindowToFront(const Napi::CallbackInfo &info)
+{   
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    auto returnError = [&](const std::string& message, DWORD errorCode = 0) {
+        result.Set("success", false);
+        result.Set("error", message);
+        if (errorCode != 0) {
+            result.Set("errorCode", Napi::Number::New(env, errorCode));
+        }
+        return result;
+    };
+
+    if (info.Length() < 1 || !info[0].IsString())
+    {
+        return returnError("Window name must be provided as a string");
+    }
+
+    std::string windowName = info[0].As<Napi::String>().Utf8Value();
+
+    HWND hWnd = GetWindowByName(windowName.c_str());
+    if (!hWnd || !IsWindow(hWnd))
+    {
+        return returnError("Window not found or invalid: " + windowName);
+    }
+
+    // Restore if minimized
+    if (IsIconic(hWnd))
+    {
+        ShowWindow(hWnd, SW_RESTORE);
+        // Give the window a moment to restore before trying to focus it
+        Sleep(50);
+    }
+
+    HWND fg = GetForegroundWindow();
+
+    // Bug fix 1: must attach the TARGET window's thread, not just the foreground
+    // window's thread. We need a triangle: cur <-> fg thread <-> target thread.
+    DWORD fgThread  = fg ? GetWindowThreadProcessId(fg, nullptr) : 0;
+    DWORD tgtThread = GetWindowThreadProcessId(hWnd, nullptr);
+    DWORD curThread = GetCurrentThreadId();
+
+    // Bug fix 2: attach all relevant thread pairs so input state is fully shared
+    bool attachedFg  = (fgThread  && fgThread  != curThread) ? AttachThreadInput(curThread, fgThread,  TRUE) != 0 : false;
+    bool attachedTgt = (tgtThread && tgtThread != curThread) ? AttachThreadInput(curThread, tgtThread, TRUE) != 0 : false;
+
+    // Bug fix 3: use AllowSetForegroundWindow to explicitly grant permission,
+    // which bypasses Windows' focus-stealing prevention for cross-process calls
+    AllowSetForegroundWindow(ASFW_ANY);
+
+    // Bring the window to front using the full sequence
+    SetForegroundWindow(hWnd);
+    SetActiveWindow(hWnd);
+    BringWindowToTop(hWnd);
+    // Bug fix 4: SetFocus only works reliably once input queues are attached
+    SetFocus(hWnd);
+
+    // Always detach — don't leave threads attached on any code path
+    if (attachedFg)  AttachThreadInput(curThread, fgThread,  FALSE);
+    if (attachedTgt) AttachThreadInput(curThread, tgtThread, FALSE);
+
+    // Verify it actually worked
+    HWND newFg = GetForegroundWindow();
+    if (newFg != hWnd)
+    {
+        return returnError("Window did not come to foreground (focus-stealing prevention may be active)");
+    }
+
+    result.Set("success", true);
     return result;
 }

package/src/cpp/main.cpp

@@ -9,6 +9,7 @@
 
 Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
+    
     exports.Set("getWindowData", Napi::Function::New(env, GetWindowData));
     exports.Set("captureWindowN", Napi::Function::New(env, CaptureWindow));
     exports.Set("captureScreenAsync", Napi::Function::New(env, CaptureScreenAsync));
@@ -27,9 +28,13 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set("blur", Napi::Function::New(env, Blur));
     exports.Set("bgrToGray", Napi::Function::New(env, BgrToGray));
     exports.Set("equalizeHist", Napi::Function::New(env, EqualizeHist));
+    exports.Set("darkenColor", Napi::Function::New(env, DarkenColor));
     exports.Set("drawRectangle", Napi::Function::New(env, DrawRectangle));
     exports.Set("getRegion", Napi::Function::New(env, GetRegion));
     exports.Set("textRecognition", Napi::Function::New(env, TextRecognition));
+    exports.Set("bringWindowToFront", Napi::Function::New(env, BringWindowToFront));
+    exports.Set("startMouseListener", Napi::Function::New(env, StartMouseListener));
+    exports.Set("stopMouseListener", Napi::Function::New(env, StopMouseListener));
     static GdiPlusInitializer gdiplusInitializer;
      // Register cleanup hook
     env.AddCleanupHook(CleanupHook);

package/src/cpp/mouse.cpp

@@ -1,6 +1,11 @@
 // patrially used code from https://github.com/octalmage/robotjs witch is under MIT License Copyright (c) 2014 Jason Stallings
 #include <napi.h>
 #include <windows.h>
+
+HHOOK mouseHook;
+Napi::ThreadSafeFunction tsfn;
+static HANDLE hHookThread = NULL;
+static DWORD  hookThreadId = 0;
 /**
  * Move the mouse to a specific point.
  * @param point The coordinates to move the mouse to (x, y).
@@ -173,3 +178,150 @@ Napi::Value DragMouse(const Napi::CallbackInfo &info)
 
     return Napi::Boolean::New(env, true);
 }
+
+
+LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam)
+{
+    if (nCode >= 0)
+    {
+        MSLLHOOKSTRUCT *mouse = (MSLLHOOKSTRUCT *)lParam;
+
+        int x = mouse->pt.x;
+        int y = mouse->pt.y;
+
+        std::string type = "move";
+
+        switch (wParam)
+        {
+        case WM_LBUTTONDOWN:
+            type = "leftDown";
+            break;
+        case WM_LBUTTONUP:
+            type = "leftUp";
+            break;
+        case WM_RBUTTONDOWN:
+            type = "rightDown";
+            break;
+        case WM_RBUTTONUP:
+            type = "rightUp";
+            break;
+        case WM_MBUTTONDOWN:
+            type = "middleDown";
+            break;
+        case WM_MBUTTONUP:
+            type = "middleUp";
+            break;
+        case WM_MOUSEMOVE:
+            type = "move";
+            break;
+        }
+
+        auto callback = [x, y, type](Napi::Env env, Napi::Function jsCallback)
+        {
+            Napi::Object event = Napi::Object::New(env);
+            event.Set("x", x);
+            event.Set("y", y);
+            event.Set("type", type);
+
+            jsCallback.Call({event});
+        };
+
+        tsfn.BlockingCall(callback);
+    }
+
+    return CallNextHookEx(mouseHook, nCode, wParam, lParam);
+}
+
+
+DWORD WINAPI HookThread(LPVOID)
+{
+    mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc, NULL, 0);
+
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0))
+    {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+
+    UnhookWindowsHookEx(mouseHook);
+    mouseHook = NULL;
+    return 0;
+}
+
+Napi::Value StartMouseListener(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    if (!info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    // Bug fix: prevent double-start leaking a thread and hook
+    if (hHookThread != NULL)
+    {
+        Napi::TypeError::New(env, "Mouse listener already running").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    Napi::Function callback = info[0].As<Napi::Function>();
+
+    tsfn = Napi::ThreadSafeFunction::New(
+        env,
+        callback,
+        "MouseListener",
+        0,
+        1);
+
+    // Store handle and thread ID so StopMouseListener can signal and wait
+    hHookThread = CreateThread(NULL, 0, HookThread, NULL, 0, &hookThreadId);
+
+    return Napi::Boolean::New(env, true);
+}
+
+
+Napi::Value StopMouseListener(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    if (hHookThread == NULL)
+    {
+        result.Set("success", false);
+        result.Set("error", "No listener is running");
+        return result;
+    }
+
+    // PostThreadMessage with WM_QUIT breaks the GetMessage loop in HookThread,
+    // which then runs UnhookWindowsHookEx and exits
+    if (!PostThreadMessage(hookThreadId, WM_QUIT, 0, 0))
+    {
+        result.Set("success", false);
+        result.Set("error", "Failed to signal hook thread");
+        result.Set("errorCode", Napi::Number::New(env, GetLastError()));
+        return result;
+    }
+
+    // Wait for the thread to fully exit before releasing resources
+    DWORD waitResult = WaitForSingleObject(hHookThread, 3000);
+    if (waitResult != WAIT_OBJECT_0)
+    {
+        // Thread didn't exit in time — force it and warn
+        TerminateThread(hHookThread, 1);
+        result.Set("success", false);
+        result.Set("error", "Hook thread did not exit cleanly, was forcefully terminated");
+    }
+    else
+    {
+        result.Set("success", true);
+    }
+
+    // Release the TSFN so Node.js can garbage collect the JS callback
+    tsfn.Release();
+
+    CloseHandle(hHookThread);
+    hHookThread = NULL;
+    hookThreadId = 0;
+
+    return result;
+}

package/src/cpp/opencv.cpp

@@ -234,6 +234,9 @@ Napi::Value BgrToGray(const Napi::CallbackInfo &info)
     return result;
 }
 
+
+
+
 Napi::Value EqualizeHist(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -453,20 +456,90 @@ Napi::Value GetRegion(const Napi::CallbackInfo &info)
     return result;
 }
 
-// Napi::Value ReadImage(const Napi::CallbackInfo &info)
-// {
-//     Napi::Env env = info.Env();
-//     std::string imagePath = info[0].As<Napi::String>();
 
-//     cv::Mat image = cv::imread(imagePath, cv::IMREAD_COLOR);
-//     if (image.empty())
-//     {
-//         Napi::TypeError::New(env, "Could not read the image").ThrowAsJavaScriptException();
-//         return env.Null();
-//     }
 
-//     cv::Mat grayImage;
-//     cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
 
-//     return Napi::Number::New(env, grayImage.rows * grayImage.cols);
-// }
+
+Napi::Value DarkenColor(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+
+    // Validate arguments: (imageData: Object, lowerBound: Array, upperBound: Array, number darkFactor)
+    if (info.Length() < 4 ||
+        !info[0].IsObject() ||
+        !info[1].IsArray() ||
+        !info[2].IsArray() ||
+        !info[3].IsNumber()) {
+        Napi::TypeError::New(env, "Invalid arguments. Expected: (object, array, array, number)")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object imageData = info[0].As<Napi::Object>();
+    Napi::Array lowerArray = info[1].As<Napi::Array>();
+    Napi::Array upperArray = info[2].As<Napi::Array>();
+    double darkFactor = info[3].ToNumber().DoubleValue();
+
+    // Validate imageData object properties
+    if (!imageData.Has("width") || !imageData.Has("height") || !imageData.Has("data")) {
+        Napi::TypeError::New(env, "Invalid image data object. Expected properties: 'width', 'height', 'data'")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    // Validate bounds arrays length
+    if (lowerArray.Length() != 3 || upperArray.Length() != 3) {
+        Napi::TypeError::New(env, "Lower and upper color bounds must be arrays of length 3")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    int width = imageData.Get("width").ToNumber().Int32Value();
+    int height = imageData.Get("height").ToNumber().Int32Value();
+
+    if (!imageData.Get("data").IsTypedArray()) {
+        Napi::TypeError::New(env, "'data' property must be a TypedArray")
+            .ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Uint8Array uint8Array = imageData.Get("data").As<Napi::Uint8Array>();
+    // Account for potential byteOffset in the typed array.
+    uint8_t* dataPtr = reinterpret_cast<uint8_t*>(uint8Array.ArrayBuffer().Data()) + uint8Array.ByteOffset();
+
+    // Create a cv::Mat using the underlying data of the Uint8Array.
+    cv::Mat inputImage(height, width, CV_8UC3, dataPtr);
+    cv::Mat image;
+    cv::cvtColor(inputImage, image, cv::COLOR_BGR2RGB);
+    // Create lower and upper bounds from the provided arrays.
+    cv::Scalar lower_bound(
+        lowerArray.Get((uint32_t)0).ToNumber().DoubleValue(),
+        lowerArray.Get((uint32_t)1).ToNumber().DoubleValue(),
+        lowerArray.Get((uint32_t)2).ToNumber().DoubleValue()
+    );
+    cv::Scalar upper_bound(
+        upperArray.Get((uint32_t)0).ToNumber().DoubleValue(),
+        upperArray.Get((uint32_t)1).ToNumber().DoubleValue(),
+        upperArray.Get((uint32_t)2).ToNumber().DoubleValue()
+    );
+
+    // Loop through the image pixels and darken the ones within the color range
+    for (int y = 0; y < image.rows; y++) {
+        for (int x = 0; x < image.cols; x++) {
+            cv::Vec3b& color = image.at<cv::Vec3b>(y, x);
+
+            // Check if the pixel is within the color range
+            if (color[0] >= lower_bound[0] && color[0] <= upper_bound[0] &&
+                color[1] >= lower_bound[1] && color[1] <= upper_bound[1] &&
+                color[2] >= lower_bound[2] && color[2] <= upper_bound[2]) {
+
+                // Darken the pixel by scaling down its color values
+                color[0] = std::max(0, int(color[0] * darkFactor));
+                color[1] = std::max(0, int(color[1] * darkFactor));
+                color[2] = std::max(0, int(color[2] * darkFactor));
+            }
+        }
+    }
+    cv::cvtColor(image, inputImage, cv::COLOR_RGB2BGR);
+    // Return the modified imageData (which shares the same underlying data).
+    return imageData;
+}

package/src/index.mts

@@ -107,6 +107,8 @@ export type Imread = (path: string) => ImageData;
 
 export type Imwrite = (image: ImageData) => Buffer;
 
+export type StartMouseListener = (callback: (data: {x: number, y: number, type: string}) => void) => void;
+export type StopMouseListener = () => {success: boolean, error?: string, errorCode?: number};
 export type MatchTemplate = (
   image: ImageData,
   template: ImageData,
@@ -121,6 +123,9 @@ export type Blur = (
 ) => ImageData;
 export type BgrToGray = (image: ImageData) => ImageData;
 export type EqualizeHist = (image: ImageData) => ImageData;
+
+export type ColorBound = [number, number, number]
+export type DarkenColor = (image: ImageData, lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) => ImageData;
 export type DrawRectangle = (
   image: ImageData,
   start: Point,
@@ -132,7 +137,7 @@ export type GetRegion = (image: ImageData, region: ROI) => ImageData;
 
 export type TextRecognition = (trainedDataPath: string, dataLang: string, imagePath: string) => string;
 export type CaptureScreenAsync = () => Promise<Buffer>;
-
+export type BringWindowToFront = (windowName: string) => boolean;
 const {
   setKeyDownCallback,
   setKeyUpCallback,
@@ -154,7 +159,12 @@ const {
   drawRectangle,
   getRegion,
   textRecognition,
-  equalizeHist
+  equalizeHist,
+  darkenColor,
+  bringWindowToFront,
+  startMouseListener,
+  stopMouseListener
+  
 }: {
   setKeyDownCallback: SetKeyCallback;
   setKeyUpCallback: SetKeyCallback;
@@ -176,7 +186,11 @@ const {
   getRegion: GetRegion;
   textRecognition: TextRecognition;
   captureScreenAsync: CaptureScreenAsync;
-  equalizeHist: EqualizeHist
+  equalizeHist: EqualizeHist;
+  darkenColor: DarkenColor;
+  bringWindowToFront: BringWindowToFront;
+  startMouseListener: StartMouseListener;
+  stopMouseListener: StopMouseListener
 } = bindings;
 
 const rawPressKey = pressKey;
@@ -434,7 +448,38 @@ class OpenCV {
  equalizeHist() {
   return new OpenCV(equalizeHist(this.imageData));
 }
-
+rgbToHsv(rgb: ColorBound) {
+ const r_norm = rgb[0] / 255;
+ const g_norm = rgb[1] / 255;
+ const b_norm = rgb[2] / 255;
+ const Cmax = Math.max(r_norm, g_norm, b_norm);
+ const Cmin = Math.min(r_norm, g_norm, b_norm);
+ const delta = Cmax - Cmin;
+
+ let Hue = 0;
+ if (delta !== 0) {
+  switch (Cmax) {
+    case r_norm:
+      Hue = 60 * (((g_norm - b_norm) / delta) % 6);
+      break;
+    case g_norm:
+      Hue = 60 * (((b_norm - r_norm) / delta) + 2);
+      break;
+    case b_norm:
+      Hue = 60 * (((r_norm - g_norm) / delta) + 4);
+      break;
+  }
+}
+ let Saturation = 0.0 * 100;
+ if(Cmax !== 0) Saturation = (delta / Cmax) * 100;
+ let Value = Cmax * 100;
+ return [
+  [Hue, Saturation, Value]
+];
+}
+darkenColor(lowerBound: ColorBound, upperBound: ColorBound, darkenFactor: number) {
+  return new OpenCV(darkenColor(this.imageData, lowerBound, upperBound, darkenFactor));
+}
 
   /**
    * Draws a rectangle on the image.
@@ -489,6 +534,7 @@ function keyPress(keyCode: number, repeat?: number): Promise<boolean> {
 
 export {
   getWindowData,
+  bringWindowToFront,
   captureWindow,
   captureWindowN,
   mouseMove,
@@ -501,6 +547,8 @@ export {
   textRecognition,
   captureScreenToFile,
   captureScreenAsync,
+  startMouseListener,
+  stopMouseListener,
   KeyboardListener,
   OpenCV
 };