ms-vite-plugin 1.4.40 → 1.4.41

package/docs/api/dotocr.md

@@ -75,7 +75,7 @@ function recognizeAbs(
   y?: number,
   ex?: number,
   ey?: number,
-  confidenceThreshold?: number,
+  confidenceThreshold?: number
 ): OCRChar[];
 ```
 
@@ -85,7 +85,7 @@ function recognizeAbs(
 | `input`               | string | 是       |        | 输入源，支持 `"screen"`、图片文件路径、URL 或 imageId                                        |
 | `x`, `y`              | number | 否       | 0      | 裁剪区域左上角坐标                                                                           |
 | `ex`, `ey`            | number | 否       | 0      | 裁剪区域右下角坐标；`ex` 或 `ey` 为 0 时分别使用图像宽度或高度                               |
-| `confidenceThreshold` | number | 否       | 0.8    | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求模板与图像像素完全一致 |
+| `confidenceThreshold` | number  | 否       | 0.8     | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求像素完全一致 |
 
 **返回值：**`OCRChar[]`。按行从上到下、同一行从左到右排列。颜色按字库各字自带的前景色/偏色匹配，无需额外传色。
 
@@ -108,7 +108,7 @@ function findTextAbs(
   ex?: number,
   ey?: number,
   confidenceThreshold?: number,
-  exactMatch?: boolean,
+  exactMatch?: boolean
 ): OCRChar[];
 ```
 
@@ -120,7 +120,7 @@ function findTextAbs(
 | `x`, `y`              | number   | 否       | 0      | 裁剪区域左上角坐标                                                    |
 | `ex`, `ey`            | number   | 否       | 0      | 裁剪区域右下角坐标；`ex` 或 `ey` 为 0 时分别使用图像宽度或高度        |
 | `confidenceThreshold` | number   | 否       | 0.8    | 单字符识别相似度下限；语义同 `recognizeAbs`                           |
-| `exactMatch`          | boolean  | 否       | false  | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
+| `exactMatch`          | boolean  | 否       | false   | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
 
 **返回值：**命中结果数组。每个目标最多返回一次命中（最先匹配到的行）；每项的 `text` 是目标字符串。
 

package/docs/api/node.md

@@ -84,6 +84,13 @@ interface NodeInfo {
   clickCenter(): boolean; // 点击中心
   clickRandom(): boolean; // 随机点击
   hittable(): boolean; // 节点是否可接收事件，用于判断节点是否在屏幕可见
+  tap(): boolean; // 无障碍点击
+  doubleTap(): boolean; // 无障碍双击
+  press(duration: number): boolean; // 无障碍长按，duration 单位毫秒
+  scrollToVisible(): boolean; // 将节点滚动到可见区域
+  clearInput(): boolean; // 清空输入
+  input(text: string): boolean; // 追加输入（聚焦后输入）
+  setValue(text: string): boolean; // 设置节点的值（见下方支持控件）
   parent(): NodeInfo | null; // 获取父节点
   child(index: number): NodeInfo | null; // 获取子节点
   allChildren(): NodeInfo[]; // 获取所有子节点
@@ -263,16 +270,81 @@ selector.releaseNode();
 #### 点击操作
 
 ```typescript
-// 点击节点中心
+// 点击节点中心（坐标点击）
 node.clickCenter(): boolean;
 
-// 随机点击节点区域
+// 随机点击节点区域（坐标点击）
 node.clickRandom(): boolean;
 
 // 节点是否可接收事件（用于判断是否显示在屏幕上）
 node.hittable(): boolean;
+
+// 无障碍点击
+node.tap(): boolean;
+
+// 无障碍双击
+node.doubleTap(): boolean;
+
+// 无障碍长按，duration 单位毫秒
+node.press(duration: number): boolean;
+
+// 将节点滚动到可见区域
+node.scrollToVisible(): boolean;
+
+// 清空输入
+node.clearInput(): boolean;
+
+// 追加输入
+node.input(text: string): boolean;
+
+// 设置节点的值
+node.setValue(text: string): boolean;
+```
+
+#### tap / doubleTap / press - 无障碍手势
+
+通过无障碍 API 直接操作节点，不依赖坐标点击。
+
+| 方法 | 参数 | 说明 |
+| --- | --- | --- |
+| `tap()` | 无 | 无障碍单击 |
+| `doubleTap()` | 无 | 无障碍双击 |
+| `press(duration)` | `duration`：长按持续时间，单位毫秒 | 无障碍长按 |
+
+**示例：**
+
+```typescript
+const selector = createNodeSelector();
+
+const btn = selector.label("确定").type("XCUIElementTypeButton").getOneNodeInfo(3000);
+if (btn) {
+  // 无障碍单击
+  btn.tap();
+
+  // 无障碍双击
+  btn.doubleTap();
+
+  // 无障碍长按 800ms
+  btn.press(800);
+}
+
+selector.releaseNode();
 ```
 
+#### setValue - 设置节点的值
+
+按控件类型自动处理，常用支持如下：
+
+| 控件类型 | 传参示例 | 说明 |
+| --- | --- | --- |
+| `XCUIElementTypePickerWheel` | `"1小时"` | 滚轮选到对应选项文案 |
+| `XCUIElementTypeTextField` | `"hello"` | 先聚焦再输入文本 |
+| `XCUIElementTypeSecureTextField` | `"123456"` | 同上 |
+| `XCUIElementTypeTextView` | `"多行内容"` | 同上 |
+| `XCUIElementTypeSearchField` | `"关键词"` | 同上 |
+
+文本类控件不会先清空已有内容；需要清空时先调用 `clearInput()`。
+
 **示例：**
 
 ```typescript
@@ -288,12 +360,27 @@ if (confirmBtn) {
   const isHittable = confirmBtn.hittable();
   logi(`是否可接收事件: ${isHittable}`);
 
-  const clicked = confirmBtn.clickCenter();
+  confirmBtn.scrollToVisible();
+  // 优先使用无障碍点击；也可用 clickCenter / clickRandom 做坐标点击
+  const clicked = confirmBtn.tap();
   if (clicked) {
     logi("成功点击确定按钮");
   }
 }
 
+// 文本框：可先清空再设值，或直接追加输入
+const field = selector.type("XCUIElementTypeTextField").getOneNodeInfo(3000);
+if (field) {
+  field.clearInput();
+  field.setValue("hello");
+}
+
+// 滚轮：传界面上的选项文案
+const wheel = selector.type("XCUIElementTypePickerWheel").getOneNodeInfo(3000);
+if (wheel) {
+  wheel.setValue("1小时");
+}
+
 // 随机点击避免检测
 const randomClick = confirmBtn?.clickRandom();
 

package/docs/api/opencv.md

@@ -5,7 +5,7 @@
 注意：
 
 - Mat 用字符串句柄表示，形如 `$CV_MAT$_…`。
-- 多数算子返回新句柄；`rectangle` / `circle` / `line` / `putText` / `fillPoly` / `polylines` / `drawContours` / `floodFill` / `ellipse` / `drawMarker` / `arrowedLine` / `fillConvexPoly` / `insertChannel` / `watershed` / `grabCut` 等会就地修改输入 Mat（或 options 中指定的目标句柄）。
+- 多数算子返回新句柄；`rectangle` / `circle` / `line` / `putText` / `fillPoly` / `polylines` / `drawContours` / `floodFill` / `ellipse` / `drawMarker` / `arrowedLine` / `fillConvexPoly` 等会就地修改输入 Mat（或 options 中指定的目标句柄）。
 - 与 `image` 可通过 `fromImageId` / `toImageId` 互通（独立拷贝）。
 - 路径 / msbundle / imageId / `screen` 等读图只用 `imread`；其它 API 只接受 Mat 句柄；`imdecode` 只解 base64。
 - 用完请 `release` / `releaseAll`（同时存活句柄上限约 32）。
@@ -17,17 +17,16 @@
 | --- | --- |
 | 读图 / 截屏 | `capture` · `imread` · `imdecode` · `imwrite` · `imencode` · `fromImageId` / `toImageId` |
 | Mat | `Mat` / `zeros` / `ones` · `clone` · `empty` / `isRelease` · `release` / `releaseAll` · `getSize` / `at` / `set` · `copyTo` |
-| 颜色 / 阈值 | `cvtColor` · `threshold` · `adaptiveThreshold` · `inRange` · `CLAHE` / `equalizeHist` · `applyColorMap` · `decolor` |
-| 算术 / 位运算 | `add` / `subtract` / `multiply` / `divide` · bitwise_* · `absdiff` · `addWeighted` · `convertScaleAbs` · `normalize` / `norm` · `meanStdDev` · `findNonZero` · `countNonZero` · `minMaxLoc` / `mean` / `sum` · `split` / `merge` · `hconcat` / `vconcat` · `LUT` · `compare` · `min` / `max` · `extractChannel` / `insertChannel` · `mixChannels` · `pow` / `sqrt` / `exp` / `log` · `magnitude` · `cartToPolar` / `polarToCart` · `PSNR` · `scaleAdd` |
-| 滤波边缘 | `GaussianBlur` / `blur` / `medianBlur` / `bilateralFilter` / `boxFilter` / `stackBlur` · `Canny` / `Sobel` / `Laplacian` / `Scharr` · `filter2D` / `sepFilter2D` · `pyrDown` / `pyrUp` · `edgePreservingFilter` · `detailEnhance` · `pencilSketch` · `stylization` · `fastNlMeansDenoising` / `fastNlMeansDenoisingColored` · `pyrMeanShiftFiltering` |
-| 几何 | `resize` / `crop` / `rotate` / `flip` · `copyMakeBorder` · `warpAffine` / `warpPerspective` / `warpPolar` · `remap` · `getRotationMatrix2D` · `getAffineTransform` · `getPerspectiveTransform` · `invertAffineTransform` · `findHomography` · `perspectiveTransform` · `estimateAffine2D` / `estimateAffinePartial2D` · `getRectSubPix` · `phaseCorrelate` |
+| 颜色 / 阈值 | `cvtColor` · `threshold` · `adaptiveThreshold` · `inRange` · `CLAHE` / `equalizeHist` |
+| 算术 / 位运算 | `add` / `subtract` / `multiply` / `divide` · bitwise_* · `absdiff` · `addWeighted` · `convertScaleAbs` · `normalize` / `norm` · `meanStdDev` · `findNonZero` · `countNonZero` · `minMaxLoc` / `mean` / `sum` · `split` / `merge` · `hconcat` / `vconcat` · `LUT` · `compare` · `min` / `max` · `extractChannel` |
+| 滤波边缘 | `GaussianBlur` / `blur` / `medianBlur` / `bilateralFilter` / `boxFilter` · `Canny` / `Sobel` / `Laplacian` / `Scharr` · `filter2D` · `pyrDown` / `pyrUp` · `fastNlMeansDenoising` / `fastNlMeansDenoisingColored` · `inpaint` |
+| 几何 | `resize` / `crop` / `rotate` / `flip` · `copyMakeBorder` · `warpAffine` / `warpPerspective` · `getRotationMatrix2D` · `getAffineTransform` · `getPerspectiveTransform` · `invertAffineTransform` · `findHomography` · `perspectiveTransform` · `estimateAffine2D` / `estimateAffinePartial2D` · `getRectSubPix` · `phaseCorrelate` |
 | 绘制 | `rectangle` / `circle` / `line` / `ellipse` / `arrowedLine` / `drawMarker` · `putText` / `fillPoly` / `fillConvexPoly` / `polylines` / `drawContours` · `getTextSize` |
-| 匹配 | `matchTemplate` / `matchTemplateLoc` · `SIFT` / `ORB` / `AKAZE` / `BRISK` / `KAZE` / `FAST` / `AGAST` / `MSER` / `SimpleBlobDetector` · `BFMatcher` / `knnMatch` · `FlannBasedMatcher` / `flannKnnMatch` · `drawKeypoints` / `drawMatches` |
+| 匹配 | `matchTemplate` / `matchTemplateLoc` · `SIFT` / `ORB` / `FAST` · `BFMatcher` / `knnMatch` · `FlannBasedMatcher` / `flannKnnMatch` · `drawKeypoints` / `drawMatches` |
 | 轮廓 | `findContours` · `boundingRect` / `minAreaRect` / `boxPoints` · `contourArea` / `arcLength` / `approxPolyDP` / `convexHull` / `convexityDefects` / `isContourConvex` · `moments` / `HuMoments` / `matchShapes` · `pointPolygonTest` · `fitEllipse` / `fitLine` / `minEnclosingCircle` |
-| 霍夫 / 连通域 / 分割 | `HoughLines` / `HoughLinesP` / `HoughCircles` / `LSD` · `connectedComponents` / `connectedComponentsWithStats` · `distanceTransform` · `floodFill` · `goodFeaturesToTrack` / `cornerHarris` / `cornerSubPix` / `cornerMinEigenVal` / `preCornerDetect` · `spatialGradient` · `watershed` / `grabCut` · `integral` |
+| 霍夫 / 连通域 | `HoughLinesP` / `HoughCircles` · `connectedComponents` / `connectedComponentsWithStats` · `distanceTransform` · `floodFill` · `goodFeaturesToTrack` / `cornerHarris` / `cornerSubPix` |
 | 直方图 | `calcHist` · `compareHist` · `calcBackProject` |
-| Photo / 克隆 | `inpaint` · `seamlessClone` · `colorChange` · `illuminationChange` · `textureFlattening` |
-| 扫码 / 检测 | `detectQRCode` · `detectBarcode` · `encodeQRCode` · `CascadeClassifier` · `HOGDetect` |
+| 扫码 | `encodeQRCode` · `detectQRCode` · `detectBarcode` |
 
 ---
 
@@ -906,37 +905,25 @@ const score = cv.compareHist(h1, h2, { method: cv.HISTCMP_CORREL });
 cv.release(h1); cv.release(h2);
 ```
 
-### boxPoints / pointPolygonTest / minEnclosingCircle / fitEllipse
-
-```typescript
-function boxPoints(options: { center: Point; size: Size | [number, number]; angle?: number }): Point[] | null;
-function pointPolygonTest(contour: Point[], ptOrOptions: Point | { pt: Point; measureDist?: boolean }): number;
-function minEnclosingCircle(points: Point[]): { center: Point; radius: number } | null;
-function fitEllipse(points: Point[]): RotatedRect | null;
-```
-
-**示例：**
-
-```javascript
-const rr = cv.minAreaRect(contour);
-const corners = cv.boxPoints(rr);
-const inside = cv.pointPolygonTest(contour, { pt: { x: 100, y: 100 } });
-```
-
-### detectQRCode / detectBarcode
+### encodeQRCode / detectQRCode / detectBarcode
 
 ```typescript
+function encodeQRCode(text: string): Mat | null;
 function detectQRCode(mat: Mat): { decoded: string; points: Point[] } | null;
 function detectBarcode(mat: Mat): { decoded: string[]; types: string[]; points: Point[] } | null;
 ```
 
+`encodeQRCode` 返回可显示/可识别的 BGR Mat（已放大并加静区），可直接交给 `detectQRCode`。
+
 **示例：**
 
 ```javascript
-const qr = cv.detectQRCode(src);
+const qrMat = cv.encodeQRCode("https://example.com");
+const qr = cv.detectQRCode(qrMat); // { decoded, points }
 if (qr) logi(qr.decoded);
 const codes = cv.detectBarcode(src);
 if (codes) logi(codes.decoded.join(","));
+cv.release(qrMat);
 ```
 
 ### filter2D / ellipse / getTextSize
@@ -1054,30 +1041,6 @@ cv.release(a.descriptors);
 cv.release(b.descriptors);
 ```
 
-### AKAZE / BRISK / FAST
-
-```typescript
-function AKAZE(mat: Mat, options?: { mask?: Mat }): FeatureResult | null;
-function BRISK(mat: Mat, options?: { thresh?: number; octaves?: number; mask?: Mat }): FeatureResult | null;
-function FAST(mat: Mat, options?: { threshold?: number; nonmaxSuppression?: boolean; mask?: Mat }): { keypoints: KeyPoint[] } | null;
-```
-
-**说明：**
-
-- `AKAZE` / `BRISK` 返回关键点 + 描述子。
-- `FAST` **只检测关键点**，无 `descriptors`。
-- `BRISK`：`thresh` 默认 30，`octaves` 默认 3。
-- `FAST`：`threshold` 默认 10，`nonmaxSuppression` 默认 `true`。
-
-**示例：**
-
-```javascript
-const fast = cv.FAST(gray, { threshold: 20 });
-logi(`FAST count=${fast.keypoints.length}`);
-const brisk = cv.BRISK(gray, { thresh: 30, octaves: 3 });
-cv.release(brisk.descriptors);
-```
-
 ### BFMatcher
 
 ```typescript
@@ -1235,75 +1198,6 @@ const d1 = cv.fastNlMeansDenoising(gray, { h: 3 });
 const d2 = cv.fastNlMeansDenoisingColored(src, { h: 3, hColor: 3 });
 ```
 
-### edgePreservingFilter / detailEnhance / stylization
-
-```typescript
-function edgePreservingFilter(mat: Mat, options?: { flags?: number; sigma_s?: number; sigma_r?: number }): Mat | null;
-function detailEnhance(mat: Mat, options?: { sigma_s?: number; sigma_r?: number }): Mat | null;
-function stylization(mat: Mat, options?: { sigma_s?: number; sigma_r?: number }): Mat | null;
-```
-
-```javascript
-const soft = cv.edgePreservingFilter(src, { flags: cv.RECURS_FILTER });
-const sharp = cv.detailEnhance(src);
-const art = cv.stylization(src);
-```
-
-### pencilSketch / decolor
-
-```typescript
-function pencilSketch(mat: Mat, options?: {
-  sigma_s?: number; sigma_r?: number; shade_factor?: number;
-}): { gray: Mat; color: Mat } | null;
-function decolor(mat: Mat): { grayscale: Mat; colorBoost: Mat } | null;
-```
-
-返回两个新句柄，用完需分别 `release`。
-
-```javascript
-const sketch = cv.pencilSketch(src);
-const dc = cv.decolor(src);
-cv.release(sketch.gray); cv.release(sketch.color);
-cv.release(dc.grayscale); cv.release(dc.colorBoost);
-```
-
-### seamlessClone
-
-```typescript
-function seamlessClone(src: Mat, options: {
-  dst: Mat; mask: Mat; p?: Point; x?: number; y?: number; flags?: number;
-}): Mat | null;
-```
-
-| 参数名 | 类型 | 是否必填 | 默认值 | 描述 |
-| --- | --- | --- | --- | --- |
-| `dst` | Mat | 是 | - | 背景图 |
-| `mask` | Mat | 是 | - | 前景有效区域 |
-| `p` / `x,y` | Point | 是 | - | 贴入中心 |
-| `flags` | number | 否 | `NORMAL_CLONE` | `NORMAL_CLONE` / `MIXED_CLONE` / `MONOCHROME_TRANSFER` |
-
-```javascript
-const blend = cv.seamlessClone(fg, { dst: bg, mask, p: { x: 200, y: 150 }, flags: cv.NORMAL_CLONE });
-```
-
-### colorChange / illuminationChange / textureFlattening
-
-```typescript
-function colorChange(mat: Mat, options: { mask: Mat; red_mul?: number; green_mul?: number; blue_mul?: number }): Mat | null;
-function illuminationChange(mat: Mat, options: { mask: Mat; alpha?: number; beta?: number }): Mat | null;
-function textureFlattening(mat: Mat, options: {
-  mask: Mat; low_threshold?: number; high_threshold?: number; kernel_size?: number;
-}): Mat | null;
-```
-
-```javascript
-const c = cv.colorChange(src, { mask, red_mul: 1.5, green_mul: 1.0, blue_mul: 0.8 });
-const i = cv.illuminationChange(src, { mask, alpha: 0.2, beta: 0.4 });
-const f = cv.textureFlattening(src, { mask });
-```
-
----
-
 ## Core 扩展
 
 ### LUT / compare / min / max
@@ -1322,168 +1216,9 @@ const mask = cv.compare(a, { src2: b, cmpop: cv.CMP_GT });
 const lo = cv.min(a, { src2: b });
 ```
 
-### extractChannel / insertChannel / mixChannels
-
-```typescript
-function extractChannel(mat: Mat, options: { coi: number }): Mat | null;
-/** 就地写入 dst，返回 dst 句柄 */
-function insertChannel(srcChannel: Mat, options: { dst: Mat; coi: number }): Mat | null;
-/** 就地改写 dst，成功返回 true */
-function mixChannels(options: { src: Mat[]; dst: Mat[]; fromTo: number[] }): boolean;
-```
-
-```javascript
-const b = cv.extractChannel(src, { coi: 0 });
-cv.insertChannel(b, { dst: out, coi: 0 }); // 就地改 out
-cv.mixChannels({ src: [src], dst: [out], fromTo: [0, 2, 1, 1, 2, 0] });
-```
-
-### pow / sqrt / exp / log / magnitude / cartToPolar / polarToCart
-
-```typescript
-function pow(mat: Mat, options: { power: number }): Mat | null;
-function sqrt(mat: Mat): Mat | null;
-function exp(mat: Mat): Mat | null;
-function log(mat: Mat): Mat | null;
-function magnitude(options: { x: Mat; y: Mat }): Mat | null;
-function cartToPolar(options: { x: Mat; y: Mat; angleInDegrees?: boolean }): { magnitude: Mat; angle: Mat } | null;
-function polarToCart(options: { magnitude: Mat; angle: Mat; angleInDegrees?: boolean }): { x: Mat; y: Mat } | null;
-```
-
-```javascript
-const mag = cv.magnitude({ x: dx, y: dy });
-const polar = cv.cartToPolar({ x: dx, y: dy, angleInDegrees: true });
-cv.release(polar.magnitude); cv.release(polar.angle);
-```
-
-### PSNR / scaleAdd / sum
-
-```typescript
-function PSNR(src1: Mat, options: { src2: Mat; R?: number }): number;
-function scaleAdd(src1: Mat, options: { alpha: number; src2: Mat }): Mat | null;
-function sum(mat: Mat): number[] | null;
-```
-
-```javascript
-const psnr = cv.PSNR(a, { src2: b });
-const s = cv.sum(src); // 各通道和
-```
-
----
-
 ## Imgproc 几何 / 滤波扩展
 
-### stackBlur / sepFilter2D / remap / warpPolar
-
-```typescript
-function stackBlur(mat: Mat, options: { ksize: number | [number, number] | Size }): Mat | null;
-function sepFilter2D(mat: Mat, options: { kernelX: Mat; kernelY: Mat; ddepth?: number; delta?: number }): Mat | null;
-function remap(mat: Mat, options: { map1: Mat; map2: Mat; interpolation?: number; borderMode?: number }): Mat | null;
-function warpPolar(mat: Mat, options: {
-  width?: number; height?: number;
-  center: Point; maxRadius: number; flags?: number;
-}): Mat | null;
-```
-
-```javascript
-const blur = cv.stackBlur(src, { ksize: 7 });
-const polar = cv.warpPolar(src, {
-  width: 300, height: 300, center: { x: 160, y: 160 }, maxRadius: 150,
-  flags: cv.INTER_LINEAR | cv.WARP_POLAR_LINEAR,
-});
-```
-
-### invertAffineTransform / getRectSubPix / phaseCorrelate
-
-```typescript
-function invertAffineTransform(M: Mat): Mat | null;
-function getRectSubPix(mat: Mat, options: {
-  patchSize: Size | [number, number]; center: Point;
-}): Mat | null;
-function phaseCorrelate(src1: Mat, options: { src2: Mat; window?: Mat }): {
-  x: number; y: number; response?: number;
-} | null;
-```
-
-```javascript
-const inv = cv.invertAffineTransform(M);
-const shift = cv.phaseCorrelate(a, { src2: b });
-```
-
-### HoughLines / LSD
-
-```typescript
-function HoughLines(mat: Mat, options?: {
-  rho?: number; theta?: number; threshold?: number; srn?: number; stn?: number;
-}): Array<{ rho: number; theta: number }> | null;
-function LSD(mat: Mat, options?: object): Array<{ x1: number; y1: number; x2: number; y2: number }> | null;
-```
-
-```javascript
-const lines = cv.HoughLines(edges, { threshold: 80 });
-const segs = cv.LSD(gray);
-```
-
-### cornerHarris / cornerSubPix / cornerMinEigenVal / preCornerDetect / spatialGradient
-
-```typescript
-function cornerHarris(mat: Mat, options?: { blockSize?: number; ksize?: number; k?: number }): Mat | null;
-function cornerSubPix(mat: Mat, options: {
-  corners: Point[]; winSize?: Size | [number, number]; zeroZone?: Size | [number, number];
-  criteria?: { type?: number; maxCount?: number; epsilon?: number };
-}): Point[] | null;
-function cornerMinEigenVal(mat: Mat, options?: { blockSize?: number; ksize?: number }): Mat | null;
-function preCornerDetect(mat: Mat, options?: { ksize?: number }): Mat | null;
-function spatialGradient(mat: Mat, options?: { ksize?: number }): { dx: Mat; dy: Mat } | null;
-```
-
-```javascript
-const corners = cv.goodFeaturesToTrack(gray, { maxCorners: 50, qualityLevel: 0.01, minDistance: 10 });
-const refined = cv.cornerSubPix(gray, { corners, winSize: [5, 5] });
-const g = cv.spatialGradient(gray);
-cv.release(g.dx); cv.release(g.dy);
-```
-
-### calcBackProject / applyColorMap / HuMoments / pyrMeanShiftFiltering / integral
-
-```typescript
-function calcBackProject(mat: Mat, options: {
-  hist: Mat; channels?: number[]; ranges?: number[]; scale?: number;
-}): Mat | null;
-function applyColorMap(mat: Mat, options: { colormap: number }): Mat | null;
-function HuMoments(contourOrMoments: Point[] | object | Mat): number[] | null;
-function pyrMeanShiftFiltering(mat: Mat, options?: { sp?: number; sr?: number; maxLevel?: number }): Mat | null;
-function integral(mat: Mat): Mat | null;
-```
-
-```javascript
-const back = cv.calcBackProject(hsv, { hist, channels: [0], ranges: [0, 180] });
-const heat = cv.applyColorMap(gray, { colormap: cv.COLORMAP_JET });
-const hu = cv.HuMoments(contour); // length 7
-```
-
-### drawMarker / arrowedLine / fillConvexPoly（就地）
-
-```typescript
-function drawMarker(mat: Mat, options: {
-  position: Point; color?: number[] | string;
-  markerType?: number; markerSize?: number; thickness?: number;
-}): Mat | null;
-function arrowedLine(mat: Mat, options: {
-  pt1: Point; pt2: Point; color?: number[] | string; thickness?: number; tipLength?: number;
-}): Mat | null;
-function fillConvexPoly(mat: Mat, options: { pts: Point[]; color?: number[] | string }): Mat | null;
-```
-
-就地修改输入 Mat，返回同一句柄。
-
-```javascript
-cv.drawMarker(src, { position: { x: 100, y: 80 }, markerType: cv.MARKER_CROSS });
-cv.arrowedLine(src, { pt1: { x: 10, y: 10 }, pt2: { x: 200, y: 120 }, color: [0, 0, 255] });
-cv.fillConvexPoly(src, { pts: [{ x: 10, y: 10 }, { x: 100, y: 20 }, { x: 50, y: 80 }], color: [0, 255, 0] });
-```
-
-### connectedComponents / convexityDefects / isContourConvex / fitLine
+### connectedComponents / convexityDefects / isContourConvex / fitLine / fitEllipse
 
 ```typescript
 function connectedComponents(mat: Mat, options?: { connectivity?: number }): { count: number; labels: Mat } | null;
@@ -1493,46 +1228,29 @@ function isContourConvex(contour: Point[]): boolean;
 function fitLine(points: Point[], options?: {
   distType?: number; param?: number; reps?: number; aeps?: number;
 }): [number, number, number, number] | null;
+function fitEllipse(points: Point[]): RotatedRect | null;
 ```
 
-`hull` 可为索引数组，或与 `convexHull` 返回格式相同的 Point[]。
+`hull` 可为索引数组，或与 `convexHull` 返回格式相同的 Point[]。`fitEllipse` 至少需要 5 个点。
 
 ```javascript
 const cc = cv.connectedComponents(bin, { connectivity: 8 });
 const hull = cv.convexHull(contour);
 const defects = cv.convexityDefects(contour, { hull });
 const line = cv.fitLine(points); // [vx, vy, x0, y0]
+const ell = cv.fitEllipse(contour); // { center, size, angle }
 cv.release(cc.labels);
 ```
 
-### watershed / grabCut（就地）
+### getRectSubPix / phaseCorrelate / estimateAffine2D / estimateAffinePartial2D
 
 ```typescript
-/** 就地改写 markers，返回 markers 句柄 */
-function watershed(mat: Mat, options: { markers: Mat }): Mat | null;
-/** 就地改写 mask，返回 mask 句柄 */
-function grabCut(mat: Mat, options: {
-  mask: Mat; rect?: Rect; iterCount?: number; mode?: number;
+function getRectSubPix(mat: Mat, options: {
+  patchSize: Size | [number, number]; center: Point;
 }): Mat | null;
-```
-
-```javascript
-cv.watershed(src, { markers }); // 就地改 markers
-cv.grabCut(src, {
-  mask,
-  rect: { x: 50, y: 50, width: 200, height: 200 },
-  iterCount: 5,
-  mode: cv.GC_INIT_WITH_RECT,
-}); // 就地改 mask
-```
-
----
-
-## Calib3d / Features / Objdetect
-
-### estimateAffine2D / estimateAffinePartial2D
-
-```typescript
+function phaseCorrelate(src1: Mat, options: { src2: Mat; window?: Mat }): {
+  x: number; y: number; response?: number;
+} | null;
 function estimateAffine2D(options: {
   srcPoints: Point[]; dstPoints: Point[]; method?: number; ransacReprojThreshold?: number;
 }): Mat | null;
@@ -1541,57 +1259,34 @@ function estimateAffinePartial2D(options: {
 }): Mat | null;
 ```
 
-```javascript
-const M = cv.estimateAffine2D({
-  srcPoints, dstPoints, method: cv.RANSAC, ransacReprojThreshold: 3,
-});
-```
-
-### KAZE / MSER / SimpleBlobDetector / AGAST
-
-```typescript
-function KAZE(mat: Mat, options?: { mask?: Mat }): { keypoints: KeyPoint[]; descriptors: Mat | null } | null;
-function MSER(mat: Mat, options?: { mask?: Mat }): { keypoints: KeyPoint[] } | null;
-function SimpleBlobDetector(mat: Mat, options?: { mask?: Mat }): { keypoints: KeyPoint[] } | null;
-function AGAST(mat: Mat, options?: {
-  threshold?: number; nonmaxSuppression?: boolean; mask?: Mat;
-}): { keypoints: KeyPoint[] } | null;
-```
+`phaseCorrelate` 估计两帧位移（滚动/拖拽）；`estimateAffinePartial2D` 为相似变换（平移+旋转+等比缩放）。
 
 ```javascript
-const kaze = cv.KAZE(gray);
-const mser = cv.MSER(gray);
-const blobs = cv.SimpleBlobDetector(gray);
-const agast = cv.AGAST(gray, { threshold: 10 });
-if (kaze.descriptors) cv.release(kaze.descriptors);
+const shift = cv.phaseCorrelate(prevGray, { src2: gray });
+const M = cv.estimateAffinePartial2D({ srcPoints, dstPoints, method: cv.RANSAC });
 ```
 
-### encodeQRCode / CascadeClassifier / HOGDetect
+### drawMarker / arrowedLine / fillConvexPoly（就地）
 
 ```typescript
-function encodeQRCode(text: string): Mat | null;
-function CascadeClassifier(mat: Mat, options: {
-  cascadePath?: string; path?: string;
-  scaleFactor?: number; minNeighbors?: number; minSize?: Size | [number, number];
-}): Rect[] | null;
-function HOGDetect(mat: Mat, options?: object): Rect[] | null;
+function drawMarker(mat: Mat, options: {
+  position: Point; color?: number[] | string;
+  markerType?: number; markerSize?: number; thickness?: number;
+}): Mat | null;
+function arrowedLine(mat: Mat, options: {
+  pt1: Point; pt2: Point; color?: number[] | string; thickness?: number; tipLength?: number;
+}): Mat | null;
+function fillConvexPoly(mat: Mat, options: { pts: Point[]; color?: number[] | string }): Mat | null;
 ```
 
-`CascadeClassifier` 需自行提供 xml 级联路径。
+就地修改输入 Mat，返回同一句柄。适合调试标注匹配点、滑动方向等。
 
 ```javascript
-const qr = cv.encodeQRCode('https://example.com');
-const faces = cv.CascadeClassifier(gray, {
-  cascadePath: '/path/to/haarcascade_frontalface_alt.xml',
-  scaleFactor: 1.1,
-  minNeighbors: 3,
-});
-const people = cv.HOGDetect(src);
-cv.release(qr);
+cv.drawMarker(src, { position: { x: 100, y: 80 }, markerType: cv.MARKER_CROSS });
+cv.arrowedLine(src, { pt1: { x: 10, y: 10 }, pt2: { x: 120, y: 80 }, color: [0, 255, 0] });
+cv.fillConvexPoly(src, { pts: [{ x: 20, y: 20 }, { x: 70, y: 20 }, { x: 45, y: 60 }], color: [128, 0, 128] });
 ```
 
----
-
 ## 常用常量
 
 挂在 `cv` 上，例如：
@@ -1614,13 +1309,9 @@ cv.release(qr);
 - 形状匹配：`CONTOURS_MATCH_I1` / `I2` / `I3`
 - 连通域统计列：`CC_STAT_LEFT` / `TOP` / `WIDTH` / `HEIGHT` / `AREA`
 - 读标志：`IMREAD_COLOR`、`IMREAD_GRAYSCALE`、`IMREAD_UNCHANGED`
-- 修复 / 风格：`INPAINT_NS`、`INPAINT_TELEA`、`RECURS_FILTER`、`NORMCONV_FILTER`
-- 无缝克隆：`NORMAL_CLONE`、`MIXED_CLONE`、`MONOCHROME_TRANSFER`
+- 修复：`INPAINT_NS`、`INPAINT_TELEA`
 - 比较：`CMP_EQ` / `CMP_GT` / `CMP_GE` / `CMP_LT` / `CMP_LE` / `CMP_NE`
-- 伪彩色：`COLORMAP_JET`、`COLORMAP_VIRIDIS`、`COLORMAP_TURBO`、`COLORMAP_HOT`、…
-- 极坐标：`WARP_POLAR_LINEAR`、`WARP_POLAR_LOG`
-- 标记：`MARKER_CROSS`、`MARKER_STAR`、`MARKER_DIAMOND`、…
-- GrabCut：`GC_BGD` / `GC_FGD` / `GC_PR_BGD` / `GC_PR_FGD`、`GC_INIT_WITH_RECT` / `GC_INIT_WITH_MASK` / `GC_EVAL`
+- 标记：`MARKER_CROSS`、`MARKER_STAR`、`MARKER_DIAMOND`、`MARKER_SQUARE`、…
 
 完整列表见类型提示 `types/opencv.d.ts`。
 
@@ -1628,11 +1319,10 @@ cv.release(qr);
 
 ## 限制与建议
 
-1. 同时存活的 Mat 句柄有上限（约 32），用完请 `release`，或阶段结束 `releaseAll`；多返回值 API（如 `pencilSketch`、`decolor`、`cartToPolar`）需分别释放。
+1. 同时存活的 Mat 句柄有上限（约 32），用完请 `release`，或阶段结束 `releaseAll`。
 2. 路径 / msbundle / imageId / `screen` 只走 `imread`；其它 API 只接受 Mat 句柄。
 3. SIFT 描述子优先 `flannKnnMatch`；ORB 用 `BFMatcher` + `NORM_HAMMING`。
 4. 特征匹配前建议转灰度；大图可先 `pyrDown` / `resize`。
 5. `findHomography` 至少需要 4 对对应点，不足会返回 `null`。
-6. 绘制类、`floodFill`、`insertChannel`、`watershed`、`grabCut` 会改原图或指定目标句柄；需保留原图请先 `clone`。
-7. 与 `image` 互通时，两边句柄各自 `release`。
-8. `CascadeClassifier` 需要设备上可访问的级联 xml 路径。
+6. 绘制类、`floodFill` 会改原图或指定目标句柄；需保留原图请先 `clone`。
+7. 与 `image` 互通时，两边句柄各自 `release`。

package/docs/apicn/dotocr.md

@@ -85,7 +85,7 @@ function 识别绝对坐标(
 | `输入源`     | 字符串 | 是       |        | 输入源，支持 `"screen"`、图片文件路径、URL 或 imageId                                        |
 | `左`, `上`   | 数字   | 否       | 0      | 裁剪区域左上角坐标                                                                           |
 | `右`, `下`   | 数字   | 否       | 0      | 裁剪区域右下角坐标；`右` 或 `下` 为 0 时分别使用图像宽度或高度                               |
-| `置信度阈值` | 数字   | 否       | 0.8    | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求模板与图像像素完全一致 |
+| `置信度阈值` | 数字   | 否       | 0.8     | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求像素完全一致 |
 
 **返回值：**`数组<OCR字符>`。按行从上到下、同一行从左到右排列。颜色按字库各字自带的前景色/偏色匹配，无需额外传色。
 
@@ -121,7 +121,7 @@ function 查找文本绝对坐标(
 | `左`, `上`   | 数字          | 否       | 0      | 裁剪区域左上角坐标                                                    |
 | `右`, `下`   | 数字          | 否       | 0      | 裁剪区域右下角坐标；`右` 或 `下` 为 0 时分别使用图像宽度或高度        |
 | `置信度阈值` | 数字          | 否       | 0.8    | 单字符识别相似度下限；语义同 `识别绝对坐标`                           |
-| `完整匹配`   | 布尔值        | 否       | false  | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
+| `完整匹配`   | 布尔值        | 否       | false   | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
 
 **返回值：**命中结果数组。每个目标最多返回一次命中（最先匹配到的行）；每项的 `text` 是目标字符串。
 

package/docs/apicn/node.md

@@ -90,6 +90,13 @@ interface $节点信息 {
   点击中心(): 布尔值; // 点击中心
   点击随机范围(): 布尔值; // 随机点击
   hittable(): 布尔值; // 节点是否可接收事件，用于判断节点是否在屏幕可见
+  tap(): 布尔值; // 无障碍点击
+  doubleTap(): 布尔值; // 无障碍双击
+  press(duration: 数字): 布尔值; // 无障碍长按，duration 单位毫秒
+  scrollToVisible(): 布尔值; // 将节点滚动到可见区域
+  clearInput(): 布尔值; // 清空输入
+  input(text: 字符串): 布尔值; // 追加输入（聚焦后输入）
+  setValue(text: 字符串): 布尔值; // 设置节点的值（见下方支持控件）
   parent(): $节点信息 | null; // 获取父节点
   child(index: 数字): $节点信息 | null; // 获取子节点
   allChildren(): $节点信息[]; // 获取所有子节点
@@ -274,16 +281,82 @@ const xpathElements = 选择器.xpath("//*[@title='快点JS']").获取所有节
 #### 点击操作
 
 ```typescript
-// 点击节点中心
+// 点击节点中心（坐标点击）
 node.点击中心(): 布尔值;
 
-// 随机点击节点区域
+// 随机点击节点区域（坐标点击）
 node.点击随机范围(): 布尔值;
 
 // 节点是否可接收事件（用于判断是否显示在屏幕上）
 node.hittable(): 布尔值;
+
+// 无障碍点击
+node.tap(): 布尔值;
+
+// 无障碍双击
+node.doubleTap(): 布尔值;
+
+// 无障碍长按，duration 单位毫秒
+node.press(duration: 数字): 布尔值;
+
+// 将节点滚动到可见区域
+node.scrollToVisible(): 布尔值;
+
+// 清空输入
+node.clearInput(): 布尔值;
+
+// 追加输入
+node.input(text: 字符串): 布尔值;
+
+// 设置节点的值
+node.setValue(text: 字符串): 布尔值;
 ```
 
+#### tap / doubleTap / press - 无障碍手势
+
+通过无障碍 API 直接操作节点，不依赖坐标点击。
+
+| 方法 | 参数 | 说明 |
+| --- | --- | --- |
+| `tap()` | 无 | 无障碍单击 |
+| `doubleTap()` | 无 | 无障碍双击 |
+| `press(duration)` | `duration`：长按持续时间，单位毫秒 | 无障碍长按 |
+
+**示例：**
+
+```typescript
+const 选择器 = $创建节点选择器();
+
+const btn = 选择器.label("确定").type("XCUIElementTypeButton").获取一个节点(3000);
+if (btn) {
+  // 无障碍单击
+  btn.tap();
+
+  // 无障碍双击
+  btn.doubleTap();
+
+  // 无障碍长按 800ms
+  btn.press(800);
+}
+
+// 释放选择器内存
+选择器.释放内存();
+```
+
+#### setValue - 设置节点的值
+
+按控件类型自动处理，常用支持如下：
+
+| 控件类型 | 传参示例 | 说明 |
+| --- | --- | --- |
+| `XCUIElementTypePickerWheel` | `"1小时"` | 滚轮选到对应选项文案 |
+| `XCUIElementTypeTextField` | `"hello"` | 先聚焦再输入文本 |
+| `XCUIElementTypeSecureTextField` | `"123456"` | 同上 |
+| `XCUIElementTypeTextView` | `"多行内容"` | 同上 |
+| `XCUIElementTypeSearchField` | `"关键词"` | 同上 |
+
+文本类控件不会先清空已有内容；需要清空时先调用 `clearInput()`。
+
 **示例：**
 
 ```typescript
@@ -298,12 +371,25 @@ if (confirmBtn) {
   const isHittable = confirmBtn.hittable();
   $打印信息日志(`是否可接收事件: ${isHittable}`);
 
-  const clicked = confirmBtn.点击中心();
+  confirmBtn.scrollToVisible();
+  // 优先使用无障碍点击；也可用 点击中心 / 点击随机范围 做坐标点击
+  const clicked = confirmBtn.tap();
   if (clicked) {
     $打印信息日志("成功点击确定按钮");
   }
 }
 
+const field = 选择器.type("XCUIElementTypeTextField").获取一个节点(3000);
+if (field) {
+  field.clearInput();
+  field.setValue("hello");
+}
+
+const wheel = 选择器.type("XCUIElementTypePickerWheel").获取一个节点(3000);
+if (wheel) {
+  wheel.setValue("1小时");
+}
+
 // 随机点击避免检测
 const randomClick = confirmBtn?.点击随机范围();
 if (randomClick) {

package/docs/apipython/dotocr.md

@@ -81,7 +81,7 @@ def recognizeAbs(
 | `input`               | str   | 是       |        | 输入源，支持 `"screen"`、图片文件路径、URL 或 imageId                                        |
 | `x`, `y`              | int   | 否       | 0      | 裁剪区域左上角坐标                                                                           |
 | `ex`, `ey`            | int   | 否       | 0      | 裁剪区域右下角坐标；`ex` 或 `ey` 为 0 时分别使用图像宽度或高度                               |
-| `confidenceThreshold` | float | 否       | 0.8    | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求模板与图像像素完全一致 |
+| `confidenceThreshold` | float   | 否       | 0.8     | 相似度下限；`<=0` 时按 `0.8`；低于阈值的字符会被过滤；`>0.95` 时要求像素完全一致 |
 
 **返回值：**`List[OCRChar]`。按行从上到下、同一行从左到右排列。颜色按字库各字自带的前景色/偏色匹配，无需额外传色。
 
@@ -117,7 +117,7 @@ def findTextAbs(
 | `x`, `y`              | int       | 否       | 0      | 裁剪区域左上角坐标                                                    |
 | `ex`, `ey`            | int       | 否       | 0      | 裁剪区域右下角坐标；`ex` 或 `ey` 为 0 时分别使用图像宽度或高度        |
 | `confidenceThreshold` | float     | 否       | 0.8    | 单字符识别相似度下限；语义同 `recognizeAbs`                           |
-| `exactMatch`          | bool      | 否       | false  | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
+| `exactMatch`          | bool      | 否       | false   | `false` 为行内子串包含匹配；`true` 要求某一整行文本完全等于目标字符串 |
 
 **返回值：**命中结果数组。每个目标最多返回一次命中（最先匹配到的行）；每项的 `text` 是目标字符串。
 

package/docs/apipython/node.md

@@ -37,6 +37,13 @@ class NodeInfo:
     def clickCenter(self) -> bool: ...
     def clickRandom(self) -> bool: ...
     def hittable(self) -> bool: ...
+    def tap(self) -> bool: ...
+    def doubleTap(self) -> bool: ...
+    def press(self, duration: int = 500) -> bool: ...
+    def scrollToVisible(self) -> bool: ...
+    def clearInput(self) -> bool: ...
+    def input(self, text: str) -> bool: ...
+    def setValue(self, text: str) -> bool: ...
     def parent(self) -> Optional["NodeInfo"]: ...
     def child(self, index: int) -> Optional["NodeInfo"]: ...
     def allChildren(self) -> List["NodeInfo"]: ...
@@ -253,16 +260,80 @@ xpath_elements = selector.xpath("//*[@title='快点JS']").getNodeInfo(3000)
 ### 点击操作
 
 ```python
-# 点击节点中心
+# 点击节点中心（坐标点击）
 def clickCenter() -> bool
 
-# 随机点击节点区域
+# 随机点击节点区域（坐标点击）
 def clickRandom() -> bool
 
 # 节点是否可接收事件（用于判断是否显示在屏幕上）
 def hittable() -> bool
+
+# 无障碍点击
+def tap() -> bool
+
+# 无障碍双击
+def doubleTap() -> bool
+
+# 无障碍长按，duration 单位毫秒，默认 500
+def press(duration: int = 500) -> bool
+
+# 将节点滚动到可见区域
+def scrollToVisible() -> bool
+
+# 清空输入
+def clearInput() -> bool
+
+# 追加输入
+def input(text: str) -> bool
+
+# 设置节点的值
+def setValue(text: str) -> bool
 ```
 
+#### tap / doubleTap / press - 无障碍手势
+
+通过无障碍 API 直接操作节点，不依赖坐标点击。
+
+| 方法 | 参数 | 说明 |
+| --- | --- | --- |
+| `tap()` | 无 | 无障碍单击 |
+| `doubleTap()` | 无 | 无障碍双击 |
+| `press(duration=500)` | `duration`：长按持续时间，单位毫秒，默认 500 | 无障碍长按 |
+
+**示例：**
+
+```python
+from kuaijs import node
+
+selector = node.createNodeSelector()
+
+btn = selector.label("确定").type("XCUIElementTypeButton").getOneNodeInfo(3000)
+if btn:
+    # 无障碍单击
+    btn.tap()
+
+    # 无障碍双击
+    btn.doubleTap()
+
+    # 无障碍长按 800ms
+    btn.press(800)
+```
+
+#### setValue - 设置节点的值
+
+按控件类型自动处理，常用支持如下：
+
+| 控件类型 | 传参示例 | 说明 |
+| --- | --- | --- |
+| `XCUIElementTypePickerWheel` | `"1小时"` | 滚轮选到对应选项文案 |
+| `XCUIElementTypeTextField` | `"hello"` | 先聚焦再输入文本 |
+| `XCUIElementTypeSecureTextField` | `"123456"` | 同上 |
+| `XCUIElementTypeTextView` | `"多行内容"` | 同上 |
+| `XCUIElementTypeSearchField` | `"关键词"` | 同上 |
+
+文本类控件不会先清空已有内容；需要清空时先调用 `clearInput()`。
+
 **示例：**
 
 ```python
@@ -276,12 +347,23 @@ confirm_btn = selector.label("确定").type("XCUIElementTypeButton").getOneNodeI
 if confirm_btn:
     print(f"是否可接收事件: {confirm_btn.hittable()}")
 
-    clicked = confirm_btn.clickCenter()
+    confirm_btn.scrollToVisible()
+    # 优先使用无障碍点击；也可用 clickCenter / clickRandom 做坐标点击
+    clicked = confirm_btn.tap()
     if clicked:
         print("成功点击确定按钮")
 
-    # 随机点击避免检测
+    # 随机坐标点击避免检测
     confirm_btn.clickRandom()
+
+field = selector.type("XCUIElementTypeTextField").getOneNodeInfo(3000)
+if field:
+    field.clearInput()
+    field.setValue("hello")
+
+wheel = selector.type("XCUIElementTypePickerWheel").getOneNodeInfo(3000)
+if wheel:
+    wheel.setValue("1小时")
 ```
 
 ### 节点导航

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ms-vite-plugin",
-  "version": "1.4.40",
+  "version": "1.4.41",
   "type": "commonjs",
   "license": "MIT",
   "publishConfig": {