ppu-ocv 3.1.4 → 3.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PT. Perkasa Pilar Utama
+
+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

@@ -1,6 +1,6 @@
 # ppu-ocv
 
-[![NPM](https://img.shields.io/npm/dw/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![JSR](https://jsr.io/badges/@snowfluke/ppu-ocv)](https://jsr.io/@snowfluke/ppu-ocv)
+[![NPM](https://img.shields.io/npm/dw/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![JSR](https://jsr.io/badges/@snowfluke/ppu-ocv)](https://jsr.io/@snowfluke/ppu-ocv) [![npm version](https://img.shields.io/npm/v/ppu-ocv)](https://www.npmjs.com/package/ppu-ocv) [![Provenance](https://img.shields.io/badge/npm-signed%20provenance-blue?logo=npm)](https://www.npmjs.com/package/ppu-ocv#provenance) [![License: MIT](https://img.shields.io/npm/l/ppu-ocv)](./LICENSE) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/PT-Perkasa-Pilar-Utama/ppu-ocv/badge)](https://scorecard.dev/viewer/?uri=github.com/PT-Perkasa-Pilar-Utama/ppu-ocv) [![Socket Badge](https://socket.dev/api/badge/npm/package/ppu-ocv)](https://socket.dev/npm/package/ppu-ocv) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12961/badge)](https://www.bestpractices.dev/projects/12961)
 
 A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing. Decoupled canvas utilities run anywhere — Node, Bun, browsers, browser extensions, and service workers — with or without OpenCV.
 
@@ -231,21 +231,22 @@ setPlatform(myPlatform);
 
 To avoid bloat, we only ship essential operations for chaining. Currently shipped operations are:
 
-| Operation                 | Depends on…                                 | Why                                                             |
-| ------------------------- | ------------------------------------------- | --------------------------------------------------------------- |
-| **grayscale**             | –                                           | Converts to single‐channel; many ops expect a gray image first. |
-| **blur**                  | _(ideally after)_ grayscale                 | Noise reduction works best on 1-channel data.                   |
-| **threshold**             | _(after)_ grayscale                         | Produces a binary image; needs gray levels.                     |
-| **adaptiveThreshold**     | _(after)_ grayscale (and optionally blur)   | Local thresholding on gray values (smoother if blurred first).  |
-| **invert**                | _(after)_ threshold or adaptiveThreshold    | Inverting a binary mask flips foreground/background.            |
-| **canny**                 | _(after)_ grayscale + blur                  | Edge detection expects a smoothed gray image.                   |
-| **dilate**                | _(after)_ threshold or edge detection       | Expands foreground regions—usually on a binary mask.            |
-| **erode**                 | _(after)_ threshold or edge detection       | Shrinks or cleans up binary regions.                            |
-| **morphologicalGradient** | _(after)_ dilation + erosion (or threshold) | Highlights boundaries by subtracting eroded from dilated image. |
-| **warp**                  | –                                           | Geometric transform; can be applied at any point.               |
-| **resize**                | –                                           | Also independent; purely geometry.                              |
-| **border**                | –                                           | Independent; purely geometry.                                   |
-| **rotate**                | –                                           | Independent.                                                    |
+| Operation                 | Depends on…                                 | Why                                                                                      |
+| ------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| **grayscale**             | –                                           | Converts to single‐channel; many ops expect a gray image first.                          |
+| **blur**                  | _(ideally after)_ grayscale                 | Noise reduction works best on 1-channel data.                                            |
+| **equalize**              | _(after)_ grayscale                         | Histogram equalisation (CLAHE or global) for contrast normalisation before thresholding. |
+| **threshold**             | _(after)_ grayscale                         | Produces a binary image; needs gray levels.                                              |
+| **adaptiveThreshold**     | _(after)_ grayscale (and optionally blur)   | Local thresholding on gray values (smoother if blurred first).                           |
+| **invert**                | _(after)_ threshold or adaptiveThreshold    | Inverting a binary mask flips foreground/background.                                     |
+| **canny**                 | _(after)_ grayscale + blur                  | Edge detection expects a smoothed gray image.                                            |
+| **dilate**                | _(after)_ threshold or edge detection       | Expands foreground regions—usually on a binary mask.                                     |
+| **erode**                 | _(after)_ threshold or edge detection       | Shrinks or cleans up binary regions.                                                     |
+| **morphologicalGradient** | _(after)_ dilation + erosion (or threshold) | Highlights boundaries by subtracting eroded from dilated image.                          |
+| **warp**                  | –                                           | Geometric transform; can be applied at any point.                                        |
+| **resize**                | –                                           | Also independent; purely geometry.                                                       |
+| **border**                | –                                           | Independent; purely geometry.                                                            |
+| **rotate**                | –                                           | Independent.                                                                             |
 
 ## Extending operations
 

package/canvas-factory.d.ts

@@ -3,7 +3,7 @@
  * Allows ppu-ocv to work with both @napi-rs/canvas (Node) and browser canvas APIs.
  */
 /** Structural type satisfied by both @napi-rs/canvas Canvas and HTMLCanvasElement/OffscreenCanvas. */
-export interface CanvasLike {
+export type CanvasLike = {
     /** Canvas width in pixels. */
     width: number;
     /** Canvas height in pixels. */
@@ -14,9 +14,9 @@ export interface CanvasLike {
     toBuffer?: (...args: any[]) => Buffer;
     /** Serialize the canvas to a data-URL string (browser canvases). Absent on Node-side `@napi-rs/canvas`. */
     toDataURL?: (...args: any[]) => string;
-}
+};
 /** Structural type for 2D rendering context, matching the cross-runtime subset used by ppu-ocv. */
-export interface Context2DLike {
+export type Context2DLike = {
     /** The canvas this context is bound to. */
     canvas: any;
     /** Draw an image, canvas, or bitmap onto the context. Signature follows the standard Canvas2D `drawImage`. */
@@ -59,17 +59,28 @@ export interface Context2DLike {
     translate(x: number, y: number): void;
     /** Rotate the coordinate system clockwise by `angle` radians. */
     rotate(angle: number): void;
-}
+};
 /** Platform-specific canvas operations. Each runtime entry point registers an implementation via {@link setPlatform}. */
-export interface CanvasPlatform {
+export type CanvasPlatform = {
     /** Create a blank canvas of the given width and height. */
     createCanvas(width: number, height: number): CanvasLike;
     /** Decode an image from a buffer or URL and draw it onto a fresh canvas. */
     loadImage(source: ArrayBuffer | string): Promise<CanvasLike>;
     /** Type guard for "is this value a canvas of this platform?". */
     isCanvas(value: unknown): value is CanvasLike;
-}
+};
 /** Register the platform-specific canvas implementation */
 export declare function setPlatform(platform: CanvasPlatform): void;
 /** Get the registered platform. Throws if none has been set. */
 export declare function getPlatform(): CanvasPlatform;
+/**
+ * Structural ("duck-typed") canvas check, independent of the registered
+ * platform. A value is canvas-like if it exposes `width`/`height` numbers and a
+ * `getContext` function — true for both `@napi-rs/canvas` (Node) and browser
+ * `HTMLCanvasElement`/`OffscreenCanvas`.
+ *
+ * Unlike {@link CanvasPlatform.isCanvas}, this does not depend on which platform
+ * is globally registered, so it stays correct when the Node and web entry
+ * points are loaded in the same process (e.g. a dual-target test suite).
+ */
+export declare function isCanvasLike(value: unknown): value is CanvasLike;

package/canvas-factory.js

@@ -1 +1 @@
-let _platform=null;export function setPlatform(platform){_platform=platform}export function getPlatform(){if(!_platform){throw new Error("No canvas platform registered. "+'Import "ppu-ocv" (Node), "ppu-ocv/web" (browser), '+'"ppu-ocv/canvas" (Node canvas-only), or "ppu-ocv/canvas-web" (browser canvas-only) to auto-register.')}return _platform}
+let _platform=null;export function setPlatform(platform){_platform=platform}export function getPlatform(){if(!_platform){throw new Error("No canvas platform registered. "+'Import "ppu-ocv" (Node), "ppu-ocv/web" (browser), '+'"ppu-ocv/canvas" (Node canvas-only), or "ppu-ocv/canvas-web" (browser canvas-only) to auto-register.')}return _platform}export function isCanvasLike(value){return typeof value==="object"&&value!==null&&typeof value.getContext==="function"&&typeof value.width==="number"&&typeof value.height==="number"}

package/canvas-processor.d.ts

@@ -3,12 +3,12 @@ import type { CanvasLike } from "./canvas-factory.js";
 /**
  * A detected region returned by {@link CanvasProcessor.findRegions}.
  */
-export interface DetectedRegion {
+export type DetectedRegion = {
     /** Axis-aligned bounding box of the region (x1/y1 are exclusive). */
     bbox: BoundingBox;
     /** Number of foreground pixels in the region. */
     area: number;
-}
+};
 /**
  * Canvas-native image processing with no OpenCV dependency.
  *

package/canvas-processor.js

@@ -1 +1 @@
-export class CanvasProcessor{_canvas;constructor(source){this._canvas=source}get width(){return this._canvas.width}get height(){return this._canvas.height}resize(options){const{width,height}=options;let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").drawImage(this._canvas,0,0,width,height);this._canvas=dst;return this}grayscale(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));d[i]=luma;d[i+1]=luma;d[i+2]=luma}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}convert(options={}){const{alpha=1,beta=0}=options;if(alpha===1&&beta===0)return this;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=Math.round((d[i]??0)*alpha+beta);d[i+1]=Math.round((d[i+1]??0)*alpha+beta);d[i+2]=Math.round((d[i+2]??0)*alpha+beta)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}invert(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=255-(d[i]??0);d[i+1]=255-(d[i+1]??0);d[i+2]=255-(d[i+2]??0)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}threshold(options={}){const{thresh=127,maxValue=255}=options;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=d[i]===d[i+1]&&d[i+1]===d[i+2]?d[i]??0:Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));let val=luma>thresh?maxValue:0;d[i]=val;d[i+1]=val;d[i+2]=val}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}border(options={}){const{size=10,color="white"}=options;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width+size*2,height+size*2);let ctx=dst.getContext("2d");ctx.fillStyle=color;ctx.fillRect(0,0,dst.width,dst.height);ctx.drawImage(this._canvas,size,size);this._canvas=dst;return this}rotate(options){const{angle,cx=this._canvas.width/2,cy=this._canvas.height/2}=options;if(angle===0)return this;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width,height);let ctx=dst.getContext("2d");ctx.save();ctx.translate(cx,cy);ctx.rotate(-angle*Math.PI/180);ctx.drawImage(this._canvas,-cx,-cy);ctx.restore();this._canvas=dst;return this}findRegions(options={}){const{foreground="light",thresh=127,minArea=1,maxArea=1/0,padding,scale=1}=options;const{width,height}=this._canvas;let data=this._canvas.getContext("2d").getImageData(0,0,width,height).data;let visited=new Uint8Array(width*height);let regions=[];let neighbours=[[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]];let isForeground=(pixelIdx)=>{let r=data[pixelIdx]??0;return foreground==="light"?r>thresh:r<=thresh};for(let startY=0;startY<height;startY++){for(let startX=0;startX<width;startX++){let startFlat=startY*width+startX;if(visited[startFlat])continue;visited[startFlat]=1;if(!isForeground(startFlat*4))continue;let stack=[startFlat];let minX=startX,maxX=startX;let minY=startY,maxY=startY;let area=0;while(stack.length>0){let flat=stack.pop();if(flat===undefined)break;area++;let x=flat%width;let y=(flat-x)/width;if(x<minX)minX=x;else if(x>maxX)maxX=x;if(y<minY)minY=y;else if(y>maxY)maxY=y;for(const[dx,dy]of neighbours){let nx=x+dx;let ny=y+dy;if(nx<0||nx>=width||ny<0||ny>=height)continue;let nFlat=ny*width+nx;if(visited[nFlat])continue;visited[nFlat]=1;if(isForeground(nFlat*4))stack.push(nFlat)}}if(area>=minArea&&area<=maxArea){let x0=minX;let y0=minY;let x1=maxX+1;let y1=maxY+1;if(padding){let bboxH=y1-y0;let vPad=Math.round(bboxH*(padding.vertical??0));let hPad=Math.round(bboxH*(padding.horizontal??0));x0=Math.max(0,x0-hPad);y0=Math.max(0,y0-vPad);x1=Math.min(width,x1+hPad);y1=Math.min(height,y1+vPad)}if(scale!==1){x0=Math.max(0,Math.round(x0*scale));y0=Math.max(0,Math.round(y0*scale));x1=Math.round(x1*scale);y1=Math.round(y1*scale)}regions.push({bbox:{x0,y0,x1,y1},area})}}}return regions}toCanvas(){return this._canvas}static async prepareCanvas(file){if(getPlatform().isCanvas(file))return file;return getPlatform().loadImage(file)}static async prepareBuffer(canvas){if(canvas instanceof ArrayBuffer)return canvas;if(typeof canvas.toBuffer==="function"){let buffer=canvas.toBuffer("image/png");let arrayBuffer=new ArrayBuffer(buffer.byteLength);new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));return arrayBuffer}if(typeof canvas.toDataURL==="function"){let dataURL=canvas.toDataURL("image/png");let base64Data=dataURL.replace(/^data:image\/png;base64,/,"");let binaryString=atob(base64Data);let arrayBuffer=new ArrayBuffer(binaryString.length);let bytes=new Uint8Array(arrayBuffer);for(let i=0;i<binaryString.length;i++){bytes[i]=binaryString.charCodeAt(i)}return arrayBuffer}let ctx=canvas.getContext("2d");let imageData=ctx.getImageData(0,0,canvas.width,canvas.height);let canvasBuffer=new ArrayBuffer(imageData.data.byteLength);new Uint8Array(canvasBuffer).set(new Uint8Array(imageData.data.buffer,imageData.data.byteOffset,imageData.data.byteLength));return canvasBuffer}}import{getPlatform}from"./canvas-factory.js";
+export class CanvasProcessor{_canvas;constructor(source){this._canvas=source}get width(){return this._canvas.width}get height(){return this._canvas.height}resize(options){const{width,height}=options;let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").drawImage(this._canvas,0,0,width,height);this._canvas=dst;return this}grayscale(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));d[i]=luma;d[i+1]=luma;d[i+2]=luma}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}convert(options={}){const{alpha=1,beta=0}=options;if(alpha===1&&beta===0)return this;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=Math.round((d[i]??0)*alpha+beta);d[i+1]=Math.round((d[i+1]??0)*alpha+beta);d[i+2]=Math.round((d[i+2]??0)*alpha+beta)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}invert(){const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){d[i]=255-(d[i]??0);d[i+1]=255-(d[i+1]??0);d[i+2]=255-(d[i+2]??0)}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}threshold(options={}){const{thresh=127,maxValue=255}=options;const{width,height}=this._canvas;let imageData=this._canvas.getContext("2d").getImageData(0,0,width,height);let d=imageData.data;for(let i=0;i<d.length;i+=4){let luma=d[i]===d[i+1]&&d[i+1]===d[i+2]?d[i]??0:Math.round(0.299*(d[i]??0)+0.587*(d[i+1]??0)+0.114*(d[i+2]??0));let val=luma>thresh?maxValue:0;d[i]=val;d[i+1]=val;d[i+2]=val}let dst=getPlatform().createCanvas(width,height);dst.getContext("2d").putImageData(imageData,0,0);this._canvas=dst;return this}border(options={}){const{size=10,color="white"}=options;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width+size*2,height+size*2);let ctx=dst.getContext("2d");ctx.fillStyle=color;ctx.fillRect(0,0,dst.width,dst.height);ctx.drawImage(this._canvas,size,size);this._canvas=dst;return this}rotate(options){const{angle,cx=this._canvas.width/2,cy=this._canvas.height/2}=options;if(angle===0)return this;const{width,height}=this._canvas;let dst=getPlatform().createCanvas(width,height);let ctx=dst.getContext("2d");ctx.save();ctx.translate(cx,cy);ctx.rotate(-angle*Math.PI/180);ctx.drawImage(this._canvas,-cx,-cy);ctx.restore();this._canvas=dst;return this}findRegions(options={}){const{foreground="light",thresh=127,minArea=1,maxArea=1/0,padding,scale=1}=options;const{width,height}=this._canvas;let data=this._canvas.getContext("2d").getImageData(0,0,width,height).data;let visited=new Uint8Array(width*height);let regions=[];let neighbours=[[-1,-1],[0,-1],[1,-1],[-1,0],[1,0],[-1,1],[0,1],[1,1]];let isForeground=(pixelIdx)=>{let r=data[pixelIdx]??0;return foreground==="light"?r>thresh:r<=thresh};for(let startY=0;startY<height;startY++){for(let startX=0;startX<width;startX++){let startFlat=startY*width+startX;if(visited[startFlat])continue;visited[startFlat]=1;if(!isForeground(startFlat*4))continue;let stack=[startFlat];let minX=startX,maxX=startX;let minY=startY,maxY=startY;let area=0;while(stack.length>0){let flat=stack.pop();if(flat===undefined)break;area++;let x=flat%width;let y=(flat-x)/width;if(x<minX)minX=x;else if(x>maxX)maxX=x;if(y<minY)minY=y;else if(y>maxY)maxY=y;for(const[dx,dy]of neighbours){let nx=x+dx;let ny=y+dy;if(nx<0||nx>=width||ny<0||ny>=height)continue;let nFlat=ny*width+nx;if(visited[nFlat])continue;visited[nFlat]=1;if(isForeground(nFlat*4))stack.push(nFlat)}}if(area>=minArea&&area<=maxArea){let x0=minX;let y0=minY;let x1=maxX+1;let y1=maxY+1;if(padding){let bboxH=y1-y0;let vPad=Math.round(bboxH*(padding.vertical??0));let hPad=Math.round(bboxH*(padding.horizontal??0));x0=Math.max(0,x0-hPad);y0=Math.max(0,y0-vPad);x1=Math.min(width,x1+hPad);y1=Math.min(height,y1+vPad)}if(scale!==1){x0=Math.max(0,Math.round(x0*scale));y0=Math.max(0,Math.round(y0*scale));x1=Math.round(x1*scale);y1=Math.round(y1*scale)}regions.push({bbox:{x0,y0,x1,y1},area})}}}return regions}toCanvas(){return this._canvas}static async prepareCanvas(file){if(isCanvasLike(file))return file;return getPlatform().loadImage(file)}static async prepareBuffer(canvas){if(canvas instanceof ArrayBuffer)return canvas;if(typeof canvas.toBuffer==="function"){let buffer=canvas.toBuffer("image/png");let arrayBuffer=new ArrayBuffer(buffer.byteLength);new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));return arrayBuffer}if(typeof canvas.toDataURL==="function"){let dataURL=canvas.toDataURL("image/png");let base64Data=dataURL.replace(/^data:image\/png;base64,/,"");let binaryString=atob(base64Data);let arrayBuffer=new ArrayBuffer(binaryString.length);let bytes=new Uint8Array(arrayBuffer);for(let i=0;i<binaryString.length;i++){bytes[i]=binaryString.charCodeAt(i)}return arrayBuffer}let ctx=canvas.getContext("2d");let imageData=ctx.getImageData(0,0,canvas.width,canvas.height);let canvasBuffer=new ArrayBuffer(imageData.data.byteLength);new Uint8Array(canvasBuffer).set(new Uint8Array(imageData.data.buffer,imageData.data.byteOffset,imageData.data.byteLength));return canvasBuffer}}import{getPlatform,isCanvasLike}from"./canvas-factory.js";

package/canvas-toolkit.base.d.ts

@@ -1,10 +1,10 @@
 import type { BoundingBox } from "./index.interface.js";
 import type { CanvasLike, Context2DLike } from "./canvas-factory.js";
-/** Structural interface for contour-like objects with 32-bit signed integer point data. */
-export interface ContourLike {
+/** Structural type for contour-like objects with 32-bit signed integer point data. */
+export type ContourLike = {
     /** Flat `[x0, y0, x1, y1, ...]` point array. Matches `cv.Mat.data32S` for contour Mats. */
     data32S: Int32Array | number[];
-}
+};
 /**
  * Cross-platform base class for canvas manipulation utilities.
  * Contains only methods that work in both Node and browser environments.

package/contours.d.ts

@@ -2,12 +2,12 @@ import type { CanvasLike } from "./canvas-factory.js";
 import { cv } from "./cv-provider.js";
 import type { BoundingBox, Points } from "./index.interface.js";
 /** Options for configuring contour detection. */
-export interface ContoursOptions {
+export type ContoursOptions = {
     /** The contour retrieval mode. (cv.RETR_...) */
     mode: cv.RetrievalModes;
     /** The contour approximation method. (cv.CHAIN_...) */
     method: cv.ContourApproximationModes;
-}
+};
 /**
  * Wrapper around OpenCV's `findContours` that provides convenient accessors
  * for iterating, filtering, and analyzing contours in a binary image.

package/deskew.d.ts

@@ -2,7 +2,7 @@ import type { CanvasLike } from "./canvas-factory.js";
 /**
  * Options for configuring the deskew service
  */
-export interface DeskewOptions {
+export type DeskewOptions = {
     /**
      * Enable detailed logging of each processing step.
      * @default false
@@ -14,7 +14,7 @@ export interface DeskewOptions {
      * @default 20
      */
     minimumAreaThreshold?: number;
-}
+};
 /**
  * Service for calculating the skew angle of an image containing text.
  *

package/image-analysis.d.ts

@@ -7,7 +7,7 @@ import type { CanvasLike } from "./canvas-factory.js";
 /**
  * Options for calculating mean Lab lightness.
  */
-export interface CalculateMeanLightnessOptions {
+export type CalculateMeanLightnessOptions = {
     /** The canvas containing the image to be processed. */
     canvas: CanvasLike;
     /** The target dimensions for analysis (resizes internally). */
@@ -15,7 +15,7 @@ export interface CalculateMeanLightnessOptions {
         width: number;
         height: number;
     };
-}
+};
 /**
  * Calculates the mean normalized lightness of an image using the L channel of the Lab color space.
  * Lightness is normalized based on the image's own maximum lightness value before averaging.

package/image-processor.d.ts

@@ -1,6 +1,6 @@
 import type { CanvasLike } from "./canvas-factory.js";
 import { cv } from "./cv-provider.js";
-import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, ConvertOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions } from "./pipeline/index.js";
+import type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, ConvertOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationName, OperationOptions, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions } from "./pipeline/index.js";
 type NameWithRequiredOptions = {
     [N in OperationName]: OperationOptions<N> extends RequiredOptions ? N : never;
 }[OperationName];
@@ -83,6 +83,12 @@ export declare class ImageProcessor {
      * @param options Optional configuration for inversion
      */
     invert(options?: Partial<InvertOptions>): this;
+    /**
+     * Equalise image contrast using histogram equalization
+     * @description Usage order: (after) grayscale — input must be single-channel
+     * @param options Equalization configuration options
+     */
+    equalize(options?: Partial<EqualizeOptions>): this;
     /**
      * Canny edge detection to detect edges in the image
      * @description Usage order: (after) grayscale + blur

package/image-processor.js

@@ -1 +1 @@
-export class ImageProcessor{img;width;height;constructor(source){if(getPlatform().isCanvas(source)){let ctx=source.getContext("2d");let imageData=ctx.getImageData(0,0,source.width,source.height);this.img=cv.matFromImageData(imageData);this.width=source.width;this.height=source.height}else if(source instanceof cv.Mat){this.img=source;this.width=source.cols;this.height=source.rows}else{throw new Error("Invalid source type. Must be either Canvas or cv.Mat.")}}static async initRuntime(){return new Promise((res)=>{if(cv&&cv.Mat){res()}else{cv["onRuntimeInitialized"]=()=>{res()}}})}execute(operationName,options){let result=executeOperation(operationName,this.img,options);this.img=result.img;this.width=result.width;this.height=result.height;return this}grayscale(options){return this.execute("grayscale",options)}blur(options){return this.execute("blur",options)}threshold(options){return this.execute("threshold",options)}adaptiveThreshold(options){return this.execute("adaptiveThreshold",options)}invert(options){return this.execute("invert",options)}canny(options){return this.execute("canny",options)}dilate(options){return this.execute("dilate",options)}erode(options){return this.execute("erode",options)}border(options){return this.execute("border",options)}resize(options){return this.execute("resize",options)}rotate(options){return this.execute("rotate",options)}warp(options){return this.execute("warp",options)}convert(options){return this.execute("convert",options)}morphologicalGradient(options){return this.execute("morphologicalGradient",options)}toMat(){return this.img}toCanvas(){let platform=getPlatform();let canvas=platform.createCanvas(this.width,this.height);try{cv.imshow(canvas,this.img)}catch{let ctx=canvas.getContext("2d");if(!ctx)throw new Error("Could not get 2d context from canvas");let imgData=ctx.createImageData(this.width,this.height);if(this.img.channels()===1){let data=imgData.data;let gray=new Uint8Array(this.img.data);for(let i=0;i<gray.length;i++){data[i*4]=gray[i];data[i*4+1]=gray[i];data[i*4+2]=gray[i];data[i*4+3]=255}}else{imgData.data.set(new Uint8ClampedArray(this.img.data))}ctx.putImageData(imgData,0,0)}return canvas}destroy(){try{this.img.delete()}catch{}}}import{getPlatform}from"./canvas-factory.js";import{cv}from"./cv-provider.js";import{executeOperation}from"./pipeline/index.js";
+export class ImageProcessor{img;width;height;constructor(source){if(isCanvasLike(source)){let ctx=source.getContext("2d");let imageData=ctx.getImageData(0,0,source.width,source.height);this.img=cv.matFromImageData(imageData);this.width=source.width;this.height=source.height}else if(source instanceof cv.Mat){this.img=source;this.width=source.cols;this.height=source.rows}else{throw new Error("Invalid source type. Must be either Canvas or cv.Mat.")}}static async initRuntime(){return new Promise((res)=>{if(cv&&cv.Mat){res()}else{cv["onRuntimeInitialized"]=()=>{res()}}})}execute(operationName,options){let result=executeOperation(operationName,this.img,options);this.img=result.img;this.width=result.width;this.height=result.height;return this}grayscale(options){return this.execute("grayscale",options)}blur(options){return this.execute("blur",options)}threshold(options){return this.execute("threshold",options)}adaptiveThreshold(options){return this.execute("adaptiveThreshold",options)}invert(options){return this.execute("invert",options)}equalize(options){return this.execute("equalize",options)}canny(options){return this.execute("canny",options)}dilate(options){return this.execute("dilate",options)}erode(options){return this.execute("erode",options)}border(options){return this.execute("border",options)}resize(options){return this.execute("resize",options)}rotate(options){return this.execute("rotate",options)}warp(options){return this.execute("warp",options)}convert(options){return this.execute("convert",options)}morphologicalGradient(options){return this.execute("morphologicalGradient",options)}toMat(){return this.img}toCanvas(){let platform=getPlatform();let canvas=platform.createCanvas(this.width,this.height);try{cv.imshow(canvas,this.img)}catch{let ctx=canvas.getContext("2d");if(!ctx)throw new Error("Could not get 2d context from canvas");let imgData=ctx.createImageData(this.width,this.height);if(this.img.channels()===1){let data=imgData.data;let gray=new Uint8Array(this.img.data);for(let i=0;i<gray.length;i++){data[i*4]=gray[i];data[i*4+1]=gray[i];data[i*4+2]=gray[i];data[i*4+3]=255}}else{imgData.data.set(new Uint8ClampedArray(this.img.data))}ctx.putImageData(imgData,0,0)}return canvas}destroy(){try{this.img.delete()}catch{}}}import{getPlatform,isCanvasLike}from"./canvas-factory.js";import{cv}from"./cv-provider.js";import{executeOperation}from"./pipeline/index.js";

package/index.d.ts

@@ -13,4 +13,4 @@ export { Contours } from "./contours.js";
 export { calculateMeanGrayscaleValue, calculateMeanNormalizedLabLightness, type CalculateMeanLightnessOptions, } from "./image-analysis.js";
 export { ImageProcessor } from "./image-processor.js";
 export { DeskewService, type DeskewOptions } from "./deskew.js";
-export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";
+export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";

package/index.interface.d.ts

@@ -1,12 +1,12 @@
 /** A 2D point in canvas pixel coordinates. */
-export interface Coordinate {
+export type Coordinate = {
     /** X coordinate in pixels, measured from the left edge. */
     x: number;
     /** Y coordinate in pixels, measured from the top edge. */
     y: number;
-}
+};
 /** The four corner points of an axis-aligned rectangle, e.g. a contour bounding box. */
-export interface Points {
+export type Points = {
     /** Top-left corner. */
     topLeft: Coordinate;
     /** Top-right corner. */
@@ -15,12 +15,12 @@ export interface Points {
     bottomLeft: Coordinate;
     /** Bottom-right corner. */
     bottomRight: Coordinate;
-}
+};
 /**
  * An axis-aligned bounding box with exclusive `x1` / `y1`.
  * Width is `x1 - x0`; height is `y1 - y0`.
  */
-export interface BoundingBox {
+export type BoundingBox = {
     /** Left edge, inclusive. */
     x0: number;
     /** Top edge, inclusive. */
@@ -29,4 +29,4 @@ export interface BoundingBox {
     x1: number;
     /** Bottom edge, exclusive. */
     y1: number;
-}
+};

package/index.web.d.ts

@@ -35,4 +35,4 @@ export { Contours } from "./contours.js";
 export { calculateMeanGrayscaleValue, calculateMeanNormalizedLabLightness, type CalculateMeanLightnessOptions, } from "./image-analysis.js";
 export { ImageProcessor } from "./image-processor.js";
 export { DeskewService, type DeskewOptions } from "./deskew.js";
-export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";
+export type { AdaptiveThresholdOptions, BlurOptions, BorderOptions, CannyOptions, DilateOptions, EqualizeOptions, ErodeOptions, GrayscaleOptions, InvertOptions, MorphologicalGradientOptions, OperationFunction, OperationName, OperationOptions, OperationResult, PartialOptions, RegisteredOperations, RequiredOptions, ResizeOptions, RotateOptions, ThresholdOptions, WarpOptions, } from "./pipeline/index.js";

package/operations/adaptive-threshold.d.ts

@@ -1,7 +1,7 @@
 import { cv } from "../cv-provider.js";
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 /** Options for the adaptive threshold operation. */
-export interface AdaptiveThresholdOptions extends PartialOptions {
+export type AdaptiveThresholdOptions = PartialOptions & {
     /** Upper threshold value (0-255) */
     upper: number;
     /** Adaptive threshold method (cv.ADAPTIVE_THRESH_...) */
@@ -12,6 +12,6 @@ export interface AdaptiveThresholdOptions extends PartialOptions {
     size: number;
     /** Constant subtracted from the mean or weighted mean */
     constant: number;
-}
+};
 /** Apply adaptive thresholding to convert a grayscale image to binary. */
 export declare function adaptiveThreshold(img: cv.Mat, options: AdaptiveThresholdOptions): OperationResult;

package/operations/blur.d.ts

@@ -1,11 +1,11 @@
 import { cv } from "../cv-provider.js";
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 /** Options for the Gaussian blur operation. */
-export interface BlurOptions extends PartialOptions {
+export type BlurOptions = PartialOptions & {
     /** Size of the blur [x, y] */
     size: [number, number];
     /** Gaussian kernel standard deviation on x axis */
     sigma: number;
-}
+};
 /** Apply Gaussian blur to reduce noise. */
 export declare function blur(img: cv.Mat, options: BlurOptions): OperationResult;

package/operations/border.d.ts

@@ -1,13 +1,13 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for adding a constant-color border around the image. */
-export interface BorderOptions extends PartialOptions {
+export type BorderOptions = PartialOptions & {
     /** Size of the border in pixels */
     size: number;
     /** Border type (e.g., cv.BORDER_CONSTANT) */
     borderType: cv.BorderTypes;
     /** Border color in [B, G, R, A] format */
     borderColor: [cv.int, cv.int, cv.int, cv.int];
-}
+};
 /** Add a uniform border around the image using `cv.copyMakeBorder`. */
 export declare function border(img: cv.Mat, options: BorderOptions): OperationResult;

package/operations/canny.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the Canny edge-detection operation. */
-export interface CannyOptions extends PartialOptions {
+export type CannyOptions = PartialOptions & {
     /** Lower threshold for the hysteresis procedure (0-255) */
     lower: number;
     /** Upper threshold for the hysteresis procedure (0-255) */
     upper: number;
-}
+};
 /** Detect edges using the Canny algorithm. */
 export declare function canny(img: cv.Mat, options: CannyOptions): OperationResult;

package/operations/convert.d.ts

@@ -1,9 +1,9 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for converting a Mat to a different depth/channel type. */
-export interface ConvertOptions extends RequiredOptions {
+export type ConvertOptions = RequiredOptions & {
     /** Desired matrix type (cv.CV_...) if negative, it will be the same as input */
     rtype: number;
-}
+};
 /** Convert the image matrix to a new type via `Mat.convertTo`. */
 export declare function convert(img: cv.Mat, options: ConvertOptions): OperationResult;

package/operations/dilate.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological dilation operation. */
-export interface DilateOptions extends PartialOptions {
+export type DilateOptions = PartialOptions & {
     /** Size of the block [x, y] */
     size: [number, number];
     /** Number of iterations for the dilation operation */
     iter: number;
-}
+};
 /** Dilate the image to expand foreground regions. */
 export declare function dilate(img: cv.Mat, options: DilateOptions): OperationResult;

package/operations/equalize.d.ts

@@ -0,0 +1,34 @@
+import type { OperationResult, PartialOptions } from "../pipeline/types.js";
+import { cv } from "../cv-provider.js";
+/** Options for the histogram equalization operation. */
+export type EqualizeOptions = PartialOptions & {
+    /**
+     * Equalization algorithm to use.
+     * - `"clahe"` (default) — Contrast Limited Adaptive Histogram Equalization;
+     *   preserves local contrast and avoids over-amplification in bright regions.
+     * - `"global"` — Standard global histogram equalization via `cv.equalizeHist`;
+     *   faster but may blow out highlights.
+     */
+    method: "clahe" | "global";
+    /**
+     * CLAHE only — clip limit for contrast limiting (default `2.0`).
+     * Higher values allow more contrast; lower values are closer to global equalization.
+     */
+    clipLimit: number;
+    /**
+     * CLAHE only — tile grid size in pixels (default `8` → 8×8 tiles).
+     * The image is divided into this many tiles in each dimension.
+     */
+    tileGridSize: number;
+};
+/**
+ * Equalise histogram contrast on a single-channel (grayscale) image.
+ *
+ * Supports two algorithms selectable via {@link EqualizeOptions.method}:
+ * - `"clahe"` (default) — locally adaptive, clip-limited equalization.
+ * - `"global"` — standard whole-image histogram spreading.
+ *
+ * Input `img` must be an 8-bit single-channel `cv.Mat` (run `.grayscale()` first).
+ * The input Mat is deleted by this operation.
+ */
+export declare function equalize(img: cv.Mat, options: EqualizeOptions): OperationResult;

package/operations/equalize.js

@@ -0,0 +1 @@
+import{cv}from"../cv-provider.js";import{registry}from"../pipeline/registry.js";function defaultOptions(){return{method:"clahe",clipLimit:2,tileGridSize:8}}export function equalize(img,options){let dst=new cv.Mat;if(options.method==="global"){cv.equalizeHist(img,dst)}else{let tileSize=new cv.Size(options.tileGridSize,options.tileGridSize);let clahe=new cv.CLAHE(options.clipLimit,tileSize);clahe.apply(img,dst);clahe.delete()}img.delete();return{img:dst,width:dst.cols,height:dst.rows}}registry.register("equalize",equalize,defaultOptions);

package/operations/erode.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological erosion operation. */
-export interface ErodeOptions extends PartialOptions {
+export type ErodeOptions = PartialOptions & {
     /** Size of the block [x, y] */
     size: [number, number];
     /** Number of iterations for the erosion operation */
     iter: number;
-}
+};
 /** Erode the image to shrink foreground regions and remove small noise. */
 export declare function erode(img: cv.Mat, options: ErodeOptions): OperationResult;

package/operations/grayscale.d.ts

@@ -1,7 +1,6 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the grayscale conversion operation (no configurable fields). */
-export interface GrayscaleOptions extends PartialOptions {
-}
+export type GrayscaleOptions = PartialOptions;
 /** Convert the image to grayscale using `COLOR_RGBA2GRAY`. */
 export declare function grayscale(img: cv.Mat, _options: GrayscaleOptions): OperationResult;

package/operations/invert.d.ts

@@ -1,7 +1,6 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the bitwise-NOT color inversion operation (no configurable fields). */
-export interface InvertOptions extends PartialOptions {
-}
+export type InvertOptions = PartialOptions;
 /** Invert all pixel values using `cv.bitwise_not`. */
 export declare function invert(img: cv.Mat, _options: InvertOptions): OperationResult;

package/operations/morphological-gradient.d.ts

@@ -1,9 +1,9 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the morphological gradient operation. */
-export interface MorphologicalGradientOptions extends PartialOptions {
+export type MorphologicalGradientOptions = PartialOptions & {
     /** Kernel size for the morphological gradient operation [x, y] */
     size: [number, number];
-}
+};
 /** Apply morphological gradient to highlight edges (dilation minus erosion). */
 export declare function morphologicalGradient(img: cv.Mat, options: MorphologicalGradientOptions): OperationResult;

package/operations/resize.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for resizing the image to exact pixel dimensions. */
-export interface ResizeOptions extends RequiredOptions {
+export type ResizeOptions = RequiredOptions & {
     /** Width of the resized image */
     width: number;
     /** Height of the resized image */
     height: number;
-}
+};
 /** Resize the image to the given width and height. */
 export declare function resize(img: cv.Mat, options: ResizeOptions): OperationResult;

package/operations/rotate.d.ts

@@ -1,11 +1,11 @@
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for rotating the image around a pivot point. */
-export interface RotateOptions extends RequiredOptions {
+export type RotateOptions = RequiredOptions & {
     /** Angle of rotation in degrees (positive for counter-clockwise) */
     angle: number;
     /** Optional center of rotation. Defaults to the image center. */
     center?: cv.Point;
-}
+};
 /** Rotate the image by the given angle around its centre (or a custom pivot). */
 export declare function rotate(img: cv.Mat, options: RotateOptions): OperationResult;

package/operations/threshold.d.ts

@@ -1,13 +1,13 @@
 import type { OperationResult, PartialOptions } from "../pipeline/types.js";
 import { cv } from "../cv-provider.js";
 /** Options for the global threshold operation. */
-export interface ThresholdOptions extends PartialOptions {
+export type ThresholdOptions = PartialOptions & {
     /** Lower threshold value (0-255) */
     lower: number;
     /** Upper threshold value (0-255) */
     upper: number;
     /** Type of thresholding (cv.THRESH_...) */
     type: cv.ThresholdTypes;
-}
+};
 /** Apply a global threshold to convert a grayscale image to binary. */
 export declare function threshold(img: cv.Mat, options: ThresholdOptions): OperationResult;

package/operations/warp.d.ts

@@ -2,7 +2,7 @@ import { cv } from "../cv-provider.js";
 import type { BoundingBox, Points } from "../index.interface.js";
 import type { OperationResult, RequiredOptions } from "../pipeline/types.js";
 /** Options for the perspective warp (four-point transform) operation. */
-export interface WarpOptions extends RequiredOptions {
+export type WarpOptions = RequiredOptions & {
     /** Four points of the source image containing x and y point in
      * topLeft, topRight, bottomLeft and BottomRight.
      * Use Contours class instance to get the points
@@ -10,6 +10,6 @@ export interface WarpOptions extends RequiredOptions {
     points: Points;
     /** A destination canvas bounding box for cropping the original canvas */
     bbox: BoundingBox;
-}
+};
 /** Apply a perspective warp using four source/destination corner points. */
 export declare function warp(img: cv.Mat, options: WarpOptions): OperationResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ppu-ocv",
-  "version": "3.1.4",
+  "version": "3.2.0",
   "description": "A type-safe, modular, chainable image processing library built on top of OpenCV.js with a fluent API leveraging pipeline processing.",
   "keywords": [
     "open-cv",
@@ -43,40 +43,12 @@
       "default": "./index.canvas-web.js"
     }
   },
-  "scripts": {
-    "task": "bun scripts/task.ts",
-    "build": "bun task build",
-    "build:test": "bun task build && bun test",
-    "build:publish": "bun task build && bun task report-size && bun task publish",
-    "type-check": "bunx tsgo --noEmit",
-    "test": "bun test --parallel=$(ls tests/*.test.ts | wc -l | tr -d ' ')",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "fmt": "oxfmt --check",
-    "fmt:fix": "oxfmt .",
-    "demo": "bunx -y serve -l 4567 .",
-    "prepare": "husky"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/uglify-js": "latest",
-    "@typescript/native-preview": "^7.0.0-dev.20260513.1",
-    "canvas": "^3.2.3",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.0.0",
-    "mitata": "latest",
-    "oxfmt": "^0.48.0",
-    "oxlint": "^1.63.0",
-    "tsx": "latest",
-    "typescript": "latest",
-    "uglify-js": ">=2.4.24"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/PT-Perkasa-Pilar-Utama/ppu-ocv.git"
   },
   "dependencies": {
-    "@napi-rs/canvas": "^0.1.69",
+    "@napi-rs/canvas": "^1.0.0",
     "@techstark/opencv-js": "^4.10.0-release.1"
   }
 }

package/pipeline/index.d.ts

@@ -7,6 +7,7 @@ import "../operations/canny.js";
 import "../operations/convert.js";
 import "../operations/dilate.js";
 import "../operations/erode.js";
+import "../operations/equalize.js";
 import "../operations/grayscale.js";
 import "../operations/invert.js";
 import "../operations/morphological-gradient.js";
@@ -21,6 +22,7 @@ export type { CannyOptions } from "../operations/canny.js";
 export type { ConvertOptions } from "../operations/convert.js";
 export type { DilateOptions } from "../operations/dilate.js";
 export type { ErodeOptions } from "../operations/erode.js";
+export type { EqualizeOptions } from "../operations/equalize.js";
 export type { GrayscaleOptions } from "../operations/grayscale.js";
 export type { InvertOptions } from "../operations/invert.js";
 export type { MorphologicalGradientOptions } from "../operations/morphological-gradient.js";

package/pipeline/index.js

@@ -1 +1 @@
-export{executeOperation,OperationRegistry,registry}from"./registry.js";import"../operations/adaptive-threshold.js";import"../operations/blur.js";import"../operations/border.js";import"../operations/canny.js";import"../operations/convert.js";import"../operations/dilate.js";import"../operations/erode.js";import"../operations/grayscale.js";import"../operations/invert.js";import"../operations/morphological-gradient.js";import"../operations/resize.js";import"../operations/rotate.js";import"../operations/threshold.js";import"../operations/warp.js";
+export{executeOperation,OperationRegistry,registry}from"./registry.js";import"../operations/adaptive-threshold.js";import"../operations/blur.js";import"../operations/border.js";import"../operations/canny.js";import"../operations/convert.js";import"../operations/dilate.js";import"../operations/erode.js";import"../operations/equalize.js";import"../operations/grayscale.js";import"../operations/invert.js";import"../operations/morphological-gradient.js";import"../operations/resize.js";import"../operations/rotate.js";import"../operations/threshold.js";import"../operations/warp.js";

package/pipeline/types.d.ts

@@ -6,6 +6,7 @@ import type { CannyOptions } from "../operations/canny.js";
 import type { ConvertOptions } from "../operations/convert.js";
 import type { DilateOptions } from "../operations/dilate.js";
 import type { ErodeOptions } from "../operations/erode.js";
+import type { EqualizeOptions } from "../operations/equalize.js";
 import type { GrayscaleOptions } from "../operations/grayscale.js";
 import type { InvertOptions } from "../operations/invert.js";
 import type { MorphologicalGradientOptions } from "../operations/morphological-gradient.js";
@@ -14,31 +15,31 @@ import type { RotateOptions } from "../operations/rotate.js";
 import type { ThresholdOptions } from "../operations/threshold.js";
 import type { WarpOptions } from "../operations/warp.js";
 /** The output produced by every pipeline operation: the transformed Mat plus its dimensions. */
-export interface OperationResult {
+export type OperationResult = {
     /** Resulting OpenCV Mat after the operation. The caller is responsible for deleting it. */
     img: cv.Mat;
     /** Width of the resulting image in pixels. */
     width: number;
     /** Height of the resulting image in pixels. */
     height: number;
-}
+};
 declare const RequiredBrand: unique symbol;
 /**
- * Marker interface for operation options that have no usable defaults and
- * must be supplied by the caller. Operation option types that extend this
+ * Marker type for operation options that have no usable defaults and
+ * must be supplied by the caller. Operation option types that intersect this
  * cannot be omitted when calling {@link ImageProcessor.execute}.
  */
-export interface RequiredOptions {
+export type RequiredOptions = {
     [RequiredBrand]?: never;
-}
+};
 declare const PartialBrand: unique symbol;
 /**
- * Marker interface for operation options that have sensible defaults.
- * Operation option types that extend this may be omitted or partially supplied.
+ * Marker type for operation options that have sensible defaults.
+ * Operation option types that intersect this may be omitted or partially supplied.
  */
-export interface PartialOptions {
+export type PartialOptions = {
     [PartialBrand]?: never;
-}
+};
 /** Signature every registered operation function must conform to. */
 export type OperationFunction<T> = (img: cv.Mat, options: T) => OperationResult;
 /**
@@ -66,6 +67,8 @@ export interface RegisteredOperations {
     convert: ConvertOptions;
     /** Morphological dilation. See {@link DilateOptions}. */
     dilate: DilateOptions;
+    /** Histogram equalisation (CLAHE or global). See {@link EqualizeOptions}. */
+    equalize: EqualizeOptions;
     /** Morphological erosion. See {@link ErodeOptions}. */
     erode: ErodeOptions;
     /** Convert to grayscale via `COLOR_RGBA2GRAY`. See {@link GrayscaleOptions}. */