@midscene/shared 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/es/img.d.ts

@@ -0,0 +1,131 @@
+import { Buffer } from 'node:buffer';
+import { NodeType } from './constants.js';
+
+interface Size$1 {
+    width: number;
+    height: number;
+}
+/**
+ * Retrieves the dimensions of an image asynchronously
+ *
+ * @param image - The image data, which can be a string path or a buffer
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfo(image: string | Buffer): Promise<Size$1>;
+/**
+ * Retrieves the dimensions of an image from a base64-encoded string
+ *
+ * @param imageBase64 - The base64-encoded image data
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfoOfBase64(imageBase64: string): Promise<Size$1>;
+declare function bufferFromBase64(imageBase64: string): Promise<Buffer>;
+/**
+ * Encodes an image file to a base64 encoded string
+ *
+ * @param image The path of the image file
+ * @param withHeader Determine whether to return data including the file header information, the default is true
+ *
+ * @returns The base64 encoded string of the image file, which may or may not include header information depending on the withHeader parameter
+ *
+ * @throws When the image type is not supported, an error will be thrown
+ */
+declare function base64Encoded(image: string, withHeader?: boolean): string;
+declare function base64ToPngFormat(base64: string): string;
+
+/**
+/**
+ * Saves a Base64-encoded image to a file
+ *
+ * @param options - An object containing the Base64-encoded image data and the output file path
+ * @param options.base64Data - The Base64-encoded image data
+ * @param options.outputPath - The path where the image will be saved
+ * @throws Error if there is an error during the saving process
+ */
+declare function saveBase64Image(options: {
+    base64Data: string;
+    outputPath: string;
+}): Promise<void>;
+/**
+ * Transforms an image path into a base64-encoded string
+ * @param inputPath - The path of the image file to be encoded
+ * @returns A Promise that resolves to a base64-encoded string representing the image file
+ */
+declare function transformImgPathToBase64(inputPath: string): Promise<string>;
+/**
+ * Resizes an image from a base64-encoded string
+ *
+ * @param base64Data - A base64-encoded string representing the image
+ * @returns A Promise that resolves to a base64-encoded string representing the resized image
+ * @throws An error if the width or height cannot be determined from the metadata
+ */
+declare function resizeImg(inputData: string | Buffer, newSize?: {
+    width: number;
+    height: number;
+}): Promise<string | Buffer>;
+/**
+ * Calculates new dimensions for an image while maintaining its aspect ratio.
+ *
+ * This function is designed to resize an image to fit within a specified maximum width and height
+ * while maintaining the original aspect ratio. If the original width or height exceeds the maximum
+ * dimensions, the image will be scaled down to fit.
+ *
+ * @param {number} originalWidth - The original width of the image.
+ * @param {number} originalHeight - The original height of the image.
+ * @returns {Object} An object containing the new width and height.
+ * @throws {Error} Throws an error if the width or height is not a positive number.
+ */
+declare function calculateNewDimensions(originalWidth: number, originalHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Trims an image and returns the trimming information, including the offset from the left and top edges, and the trimmed width and height
+ *
+ * @param image - The image to be trimmed. This can be a file path or a Buffer object containing the image data
+ * @returns A Promise that resolves to an object containing the trimming information. If the image does not need to be trimmed, this object will be null
+ */
+declare function trimImage(image: string | Buffer): Promise<{
+    trimOffsetLeft: number;
+    trimOffsetTop: number;
+    width: number;
+    height: number;
+} | null>;
+
+interface Point {
+    left: number;
+    top: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+type Rect = Point & Size;
+
+type ElementType = {
+    locator: string;
+    rect: Rect;
+    center: [number, number];
+    id: string;
+    indexId: number;
+    attributes: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+};
+declare const compositeElementInfoImg: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+}) => Promise<string>;
+declare const processImageElementInfo: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+    elementsPositionInfoWithoutText: Array<ElementType>;
+}) => Promise<{
+    compositeElementInfoImgBase64: string;
+    compositeElementInfoImgWithoutTextBase64: string;
+}>;
+
+export { base64Encoded, base64ToPngFormat, bufferFromBase64, calculateNewDimensions, compositeElementInfoImg, imageInfo, imageInfoOfBase64, processImageElementInfo, resizeImg, saveBase64Image, transformImgPathToBase64, trimImage };

package/dist/es/img.js

@@ -1,27 +1,71 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
 // src/img/info.ts
 import assert from "assert";
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 import { readFileSync } from "fs";
-import Jimp from "jimp";
-async function imageInfo(image) {
-  let jimpImage;
-  if (typeof image === "string") {
-    jimpImage = await Jimp.read(image);
-  } else if (Buffer.isBuffer(image)) {
-    jimpImage = await Jimp.read(image);
-  } else {
-    throw new Error("Invalid image input: must be a string path or a Buffer");
-  }
-  const { width, height } = jimpImage.bitmap;
-  assert(
-    width && height,
-    `Invalid image: ${typeof image === "string" ? image : "Buffer"}`
-  );
-  return { width, height };
+
+// src/img/get-jimp.ts
+var ifInBrowser = typeof window !== "undefined";
+function getJimp() {
+  return __async(this, null, function* () {
+    if (ifInBrowser) {
+      return (yield import("jimp/browser/lib/jimp.js")).default;
+    }
+    return (yield import("jimp")).default;
+  });
 }
-async function imageInfoOfBase64(imageBase64) {
-  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
-  return imageInfo(Buffer.from(base64Data, "base64"));
+
+// src/img/info.ts
+function imageInfo(image) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    let jimpImage;
+    if (typeof image === "string") {
+      jimpImage = yield Jimp.read(image);
+    } else if (Buffer2.isBuffer(image)) {
+      jimpImage = yield Jimp.read(image);
+    } else {
+      throw new Error("Invalid image input: must be a string path or a Buffer");
+    }
+    const { width, height } = jimpImage.bitmap;
+    assert(
+      width && height,
+      `Invalid image: ${typeof image === "string" ? image : "Buffer"}`
+    );
+    return { width, height };
+  });
+}
+function imageInfoOfBase64(imageBase64) {
+  return __async(this, null, function* () {
+    const buffer = yield bufferFromBase64(imageBase64);
+    return imageInfo(buffer);
+  });
+}
+function bufferFromBase64(imageBase64) {
+  return __async(this, null, function* () {
+    const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
+    return Buffer2.from(base64Data, "base64");
+  });
 }
 function base64Encoded(image, withHeader = true) {
   const imageBuffer = readFileSync(image);
@@ -41,32 +85,40 @@ function base64ToPngFormat(base64) {
 }
 
 // src/img/transform.ts
-import { Buffer as Buffer2 } from "buffer";
-import Jimp2 from "jimp";
-async function saveBase64Image(options) {
-  const { base64Data, outputPath } = options;
-  const base64Image = base64Data.split(";base64,").pop() || base64Data;
-  const imageBuffer = Buffer2.from(base64Image, "base64");
-  const image = await Jimp2.read(imageBuffer);
-  await image.writeAsync(outputPath);
+import { Buffer as Buffer3 } from "buffer";
+function saveBase64Image(options) {
+  return __async(this, null, function* () {
+    const { base64Data, outputPath } = options;
+    const base64Image = base64Data.split(";base64,").pop() || base64Data;
+    const imageBuffer = Buffer3.from(base64Image, "base64");
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(imageBuffer);
+    yield image.writeAsync(outputPath);
+  });
 }
-async function transformImgPathToBase64(inputPath) {
-  const image = await Jimp2.read(inputPath);
-  const buffer = await image.getBufferAsync(Jimp2.MIME_PNG);
-  return buffer.toString("base64");
+function transformImgPathToBase64(inputPath) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(inputPath);
+    const buffer = yield image.getBufferAsync(Jimp.MIME_PNG);
+    return buffer.toString("base64");
+  });
 }
-async function resizeImg(inputData, newSize) {
-  const isBase64 = typeof inputData === "string";
-  const imageBuffer = isBase64 ? Buffer2.from(inputData.split(";base64,").pop() || inputData, "base64") : inputData;
-  const image = await Jimp2.read(imageBuffer);
-  const { width, height } = image.bitmap;
-  if (!width || !height) {
-    throw Error("Undefined width or height from the input image.");
-  }
-  const finalNewSize = newSize || calculateNewDimensions(width, height);
-  image.resize(finalNewSize.width, finalNewSize.height);
-  const resizedBuffer = await image.getBufferAsync(Jimp2.MIME_PNG);
-  return isBase64 ? resizedBuffer.toString("base64") : resizedBuffer;
+function resizeImg(inputData, newSize) {
+  return __async(this, null, function* () {
+    const isBase64 = typeof inputData === "string";
+    const imageBuffer = isBase64 ? Buffer3.from(inputData.split(";base64,").pop() || inputData, "base64") : inputData;
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(imageBuffer);
+    const { width, height } = image.bitmap;
+    if (!width || !height) {
+      throw Error("Undefined width or height from the input image.");
+    }
+    const finalNewSize = newSize || calculateNewDimensions(width, height);
+    image.resize(finalNewSize.width, finalNewSize.height);
+    const resizedBuffer = yield image.getBufferAsync(Jimp.MIME_PNG);
+    return isBase64 ? resizedBuffer.toString("base64") : resizedBuffer;
+  });
 }
 function calculateNewDimensions(originalWidth, originalHeight) {
   const maxWidth = 2048;
@@ -87,36 +139,38 @@ function calculateNewDimensions(originalWidth, originalHeight) {
     height: Math.round(newHeight)
   };
 }
-async function trimImage(image) {
-  const jimpImage = await Jimp2.read(
-    Buffer2.isBuffer(image) ? image : Buffer2.from(image)
-  );
-  const { width, height } = jimpImage.bitmap;
-  if (width <= 3 || height <= 3) {
-    return null;
-  }
-  const trimmedImage = jimpImage.autocrop();
-  const { width: trimmedWidth, height: trimmedHeight } = trimmedImage.bitmap;
-  const trimOffsetLeft = (width - trimmedWidth) / 2;
-  const trimOffsetTop = (height - trimmedHeight) / 2;
-  if (trimOffsetLeft === 0 && trimOffsetTop === 0) {
-    return null;
-  }
-  return {
-    trimOffsetLeft: -trimOffsetLeft,
-    trimOffsetTop: -trimOffsetTop,
-    width: trimmedWidth,
-    height: trimmedHeight
-  };
+function trimImage(image) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    const jimpImage = yield Jimp.read(
+      Buffer3.isBuffer(image) ? image : Buffer3.from(image)
+    );
+    const { width, height } = jimpImage.bitmap;
+    if (width <= 3 || height <= 3) {
+      return null;
+    }
+    const trimmedImage = jimpImage.autocrop();
+    const { width: trimmedWidth, height: trimmedHeight } = trimmedImage.bitmap;
+    const trimOffsetLeft = (width - trimmedWidth) / 2;
+    const trimOffsetTop = (height - trimmedHeight) / 2;
+    if (trimOffsetLeft === 0 && trimOffsetTop === 0) {
+      return null;
+    }
+    return {
+      trimOffsetLeft: -trimOffsetLeft,
+      trimOffsetTop: -trimOffsetTop,
+      width: trimmedWidth,
+      height: trimmedHeight
+    };
+  });
 }
 
 // src/img/box-select.ts
 import assert2 from "assert";
-import { Buffer as Buffer3 } from "buffer";
-import Jimp3 from "jimp";
 var createSvgOverlay = (elements, imageWidth, imageHeight) => {
-  const createPngOverlay = async (elements2, imageWidth2, imageHeight2) => {
-    const image = new Jimp3(imageWidth2, imageHeight2, 0);
+  const createPngOverlay = (elements2, imageWidth2, imageHeight2) => __async(void 0, null, function* () {
+    const Jimp = yield getJimp();
+    const image = new Jimp(imageWidth2, imageHeight2, 0);
     const colors = [
       { rect: 4278190335, text: 4294967295 }
       // red, white
@@ -197,59 +251,59 @@ var createSvgOverlay = (elements, imageWidth, imageHeight) => {
         this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
         this.bitmap.data[idx + 3] = color.rect & 255;
       });
-      const font = await Jimp3.loadFont(Jimp3.FONT_SANS_16_WHITE);
+      const font = yield Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
       image.print(
         font,
         rectX,
         rectY,
         {
           text: element.indexId.toString(),
-          alignmentX: Jimp3.HORIZONTAL_ALIGN_CENTER,
-          alignmentY: Jimp3.VERTICAL_ALIGN_MIDDLE
+          alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+          alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
         },
         rectWidth,
         rectHeight
       );
     }
-    return image.getBufferAsync(Jimp3.MIME_PNG);
-  };
+    return image.getBufferAsync(Jimp.MIME_PNG);
+  });
   return createPngOverlay(elements, imageWidth, imageHeight);
 };
-var compositeElementInfoImg = async (options) => {
+var compositeElementInfoImg = (options) => __async(void 0, null, function* () {
+  const Jimp = yield getJimp();
   const { inputImgBase64, elementsPositionInfo } = options;
-  const imageBuffer = Buffer3.from(inputImgBase64, "base64");
-  const image = await Jimp3.read(imageBuffer);
-  const { width, height } = image.bitmap;
+  const imageBuffer = yield bufferFromBase64(inputImgBase64);
+  const { width, height } = yield imageInfo(imageBuffer);
   if (!width || !height) {
     throw Error("Image processing failed because width or height is undefined");
   }
-  const svgOverlay = await createSvgOverlay(
+  const svgOverlay = yield createSvgOverlay(
     elementsPositionInfo,
     width,
     height
   );
-  return await Jimp3.read(imageBuffer).then(async (image2) => {
-    const svgImage = await Jimp3.read(svgOverlay);
-    return image2.composite(svgImage, 0, 0, {
-      mode: Jimp3.BLEND_SOURCE_OVER,
+  return yield Jimp.read(imageBuffer).then((image) => __async(void 0, null, function* () {
+    const svgImage = yield Jimp.read(svgOverlay);
+    return image.composite(svgImage, 0, 0, {
+      mode: Jimp.BLEND_SOURCE_OVER,
       opacitySource: 1,
       opacityDest: 1
     });
-  }).then((compositeImage) => {
-    return compositeImage.getBufferAsync(Jimp3.MIME_PNG);
+  })).then((compositeImage) => {
+    return compositeImage.getBufferAsync(Jimp.MIME_PNG);
   }).then((buffer) => {
     return buffer.toString("base64");
   }).catch((error) => {
     throw error;
   });
-};
-var processImageElementInfo = async (options) => {
+});
+var processImageElementInfo = (options) => __async(void 0, null, function* () {
   const base64Image = options.inputImgBase64.split(";base64,").pop();
   assert2(base64Image, "base64Image is undefined");
   const [
     compositeElementInfoImgBase64,
     compositeElementInfoImgWithoutTextBase64
-  ] = await Promise.all([
+  ] = yield Promise.all([
     compositeElementInfoImg({
       inputImgBase64: options.inputImgBase64,
       elementsPositionInfo: options.elementsPositionInfo
@@ -263,10 +317,11 @@ var processImageElementInfo = async (options) => {
     compositeElementInfoImgBase64,
     compositeElementInfoImgWithoutTextBase64
   };
-};
+});
 export {
   base64Encoded,
   base64ToPngFormat,
+  bufferFromBase64,
   calculateNewDimensions,
   compositeElementInfoImg,
   imageInfo,

package/dist/es/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: {};
+
+export { _default as default };

package/dist/es/index.js

@@ -1,7 +1,5 @@
 // src/index.ts
-function src_default() {
-  return "hello world";
-}
+var src_default = {};
 export {
   src_default as default
 };

package/dist/es/utils.d.ts

@@ -0,0 +1,4 @@
+declare const ifInBrowser: boolean;
+declare function uuid(): string;
+
+export { ifInBrowser, uuid };

package/dist/es/utils.js

@@ -0,0 +1,13 @@
+// src/utils.ts
+import { randomUUID } from "crypto";
+var ifInBrowser = typeof window !== "undefined";
+function uuid() {
+  if (ifInBrowser) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  return randomUUID();
+}
+export {
+  ifInBrowser,
+  uuid
+};

package/dist/lib/constants.d.ts

@@ -0,0 +1,13 @@
+declare const TEXT_SIZE_THRESHOLD = 9;
+declare const TEXT_MAX_SIZE = 40;
+declare const CONTAINER_MINI_HEIGHT = 3;
+declare const CONTAINER_MINI_WIDTH = 3;
+declare enum NodeType {
+    CONTAINER = "CONTAINER Node",
+    FORM_ITEM = "FORM_ITEM Node",
+    BUTTON = "BUTTON Node",
+    IMG = "IMG Node",
+    TEXT = "TEXT Node"
+}
+
+export { CONTAINER_MINI_HEIGHT, CONTAINER_MINI_WIDTH, NodeType, TEXT_MAX_SIZE, TEXT_SIZE_THRESHOLD };

package/dist/lib/fs.d.ts

@@ -0,0 +1,14 @@
+interface PkgInfo {
+    name: string;
+    version: string;
+    dir: string;
+}
+declare function getRunningPkgInfo(dir?: string): PkgInfo | null;
+/**
+ * Find the nearest package.json file recursively
+ * @param {string} dir - Home directory
+ * @returns {string|null} - The most recent package.json file path or null
+ */
+declare function findNearestPackageJson(dir: string): string | null;
+
+export { findNearestPackageJson, getRunningPkgInfo };

package/dist/lib/fs.js

@@ -31,14 +31,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var fs_exports = {};
 __export(fs_exports, {
   findNearestPackageJson: () => findNearestPackageJson,
-  getMidscenePkgInfo: () => getMidscenePkgInfo
+  getRunningPkgInfo: () => getRunningPkgInfo
 });
 module.exports = __toCommonJS(fs_exports);
 var import_node_assert = __toESM(require("assert"));
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 var pkg;
-function getMidscenePkgInfo(dir) {
+var ifInBrowser = typeof window !== "undefined";
+function getRunningPkgInfo(dir) {
+  if (ifInBrowser) {
+    return null;
+  }
   if (pkg) {
     return pkg;
   }
@@ -51,7 +55,7 @@ function getMidscenePkgInfo(dir) {
     return pkg;
   }
   return {
-    name: "midscene-unknown-page-name",
+    name: "midscene-unknown-package-name",
     version: "0.0.0",
     dir: pkgDir
   };
@@ -70,5 +74,5 @@ function findNearestPackageJson(dir) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   findNearestPackageJson,
-  getMidscenePkgInfo
+  getRunningPkgInfo
 });

package/dist/lib/img.d.ts

@@ -0,0 +1,131 @@
+import { Buffer } from 'node:buffer';
+import { NodeType } from './constants.js';
+
+interface Size$1 {
+    width: number;
+    height: number;
+}
+/**
+ * Retrieves the dimensions of an image asynchronously
+ *
+ * @param image - The image data, which can be a string path or a buffer
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfo(image: string | Buffer): Promise<Size$1>;
+/**
+ * Retrieves the dimensions of an image from a base64-encoded string
+ *
+ * @param imageBase64 - The base64-encoded image data
+ * @returns A Promise that resolves to an object containing the width and height of the image
+ * @throws Error if the image data is invalid
+ */
+declare function imageInfoOfBase64(imageBase64: string): Promise<Size$1>;
+declare function bufferFromBase64(imageBase64: string): Promise<Buffer>;
+/**
+ * Encodes an image file to a base64 encoded string
+ *
+ * @param image The path of the image file
+ * @param withHeader Determine whether to return data including the file header information, the default is true
+ *
+ * @returns The base64 encoded string of the image file, which may or may not include header information depending on the withHeader parameter
+ *
+ * @throws When the image type is not supported, an error will be thrown
+ */
+declare function base64Encoded(image: string, withHeader?: boolean): string;
+declare function base64ToPngFormat(base64: string): string;
+
+/**
+/**
+ * Saves a Base64-encoded image to a file
+ *
+ * @param options - An object containing the Base64-encoded image data and the output file path
+ * @param options.base64Data - The Base64-encoded image data
+ * @param options.outputPath - The path where the image will be saved
+ * @throws Error if there is an error during the saving process
+ */
+declare function saveBase64Image(options: {
+    base64Data: string;
+    outputPath: string;
+}): Promise<void>;
+/**
+ * Transforms an image path into a base64-encoded string
+ * @param inputPath - The path of the image file to be encoded
+ * @returns A Promise that resolves to a base64-encoded string representing the image file
+ */
+declare function transformImgPathToBase64(inputPath: string): Promise<string>;
+/**
+ * Resizes an image from a base64-encoded string
+ *
+ * @param base64Data - A base64-encoded string representing the image
+ * @returns A Promise that resolves to a base64-encoded string representing the resized image
+ * @throws An error if the width or height cannot be determined from the metadata
+ */
+declare function resizeImg(inputData: string | Buffer, newSize?: {
+    width: number;
+    height: number;
+}): Promise<string | Buffer>;
+/**
+ * Calculates new dimensions for an image while maintaining its aspect ratio.
+ *
+ * This function is designed to resize an image to fit within a specified maximum width and height
+ * while maintaining the original aspect ratio. If the original width or height exceeds the maximum
+ * dimensions, the image will be scaled down to fit.
+ *
+ * @param {number} originalWidth - The original width of the image.
+ * @param {number} originalHeight - The original height of the image.
+ * @returns {Object} An object containing the new width and height.
+ * @throws {Error} Throws an error if the width or height is not a positive number.
+ */
+declare function calculateNewDimensions(originalWidth: number, originalHeight: number): {
+    width: number;
+    height: number;
+};
+/**
+ * Trims an image and returns the trimming information, including the offset from the left and top edges, and the trimmed width and height
+ *
+ * @param image - The image to be trimmed. This can be a file path or a Buffer object containing the image data
+ * @returns A Promise that resolves to an object containing the trimming information. If the image does not need to be trimmed, this object will be null
+ */
+declare function trimImage(image: string | Buffer): Promise<{
+    trimOffsetLeft: number;
+    trimOffsetTop: number;
+    width: number;
+    height: number;
+} | null>;
+
+interface Point {
+    left: number;
+    top: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+type Rect = Point & Size;
+
+type ElementType = {
+    locator: string;
+    rect: Rect;
+    center: [number, number];
+    id: string;
+    indexId: number;
+    attributes: {
+        nodeType: NodeType;
+        [key: string]: string;
+    };
+};
+declare const compositeElementInfoImg: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+}) => Promise<string>;
+declare const processImageElementInfo: (options: {
+    inputImgBase64: string;
+    elementsPositionInfo: Array<ElementType>;
+    elementsPositionInfoWithoutText: Array<ElementType>;
+}) => Promise<{
+    compositeElementInfoImgBase64: string;
+    compositeElementInfoImgWithoutTextBase64: string;
+}>;
+
+export { base64Encoded, base64ToPngFormat, bufferFromBase64, calculateNewDimensions, compositeElementInfoImg, imageInfo, imageInfoOfBase64, processImageElementInfo, resizeImg, saveBase64Image, transformImgPathToBase64, trimImage };