@midscene/shared 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Bytedance, Inc. and its affiliates.
+
+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

@@ -0,0 +1,7 @@
+## Documentation
+
+See https://midscenejs.com/ for details.
+
+## License
+
+Midscene is MIT licensed.

package/dist/es/constants.js

@@ -0,0 +1,15 @@
+// src/constants/index.ts
+var TEXT_SIZE_THRESHOLD = 9;
+var TEXT_MAX_SIZE = 40;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["FORM_ITEM"] = "FORM_ITEM Node";
+  NodeType2["BUTTON"] = "BUTTON Node";
+  NodeType2["IMG"] = "IMG Node";
+  NodeType2["TEXT"] = "TEXT Node";
+  return NodeType2;
+})(NodeType || {});
+export {
+  NodeType,
+  TEXT_MAX_SIZE,
+  TEXT_SIZE_THRESHOLD
+};

package/dist/es/img.js

@@ -0,0 +1,239 @@
+// src/img/info.ts
+import assert from "assert";
+import { Buffer } 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 };
+}
+async function imageInfoOfBase64(imageBase64) {
+  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
+  return imageInfo(Buffer.from(base64Data, "base64"));
+}
+function base64Encoded(image, withHeader = true) {
+  const imageBuffer = readFileSync(image);
+  if (!withHeader) {
+    return imageBuffer.toString("base64");
+  }
+  if (image.endsWith("png")) {
+    return `data:image/png;base64,${imageBuffer.toString("base64")}`;
+  }
+  if (image.endsWith("jpg") || image.endsWith("jpeg")) {
+    return `data:image/jpeg;base64,${imageBuffer.toString("base64")}`;
+  }
+  throw new Error("unsupported image type");
+}
+
+// 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);
+  console.log("Image successfully written to file.");
+}
+async function transformImgPathToBase64(inputPath) {
+  const image = await Jimp2.read(inputPath);
+  const buffer = await image.getBufferAsync(Jimp2.MIME_PNG);
+  return buffer.toString("base64");
+}
+async function resizeImg(base64Data) {
+  const base64Image = base64Data.split(";base64,").pop() || base64Data;
+  const imageBuffer = Buffer2.from(base64Image, "base64");
+  const image = await Jimp2.read(imageBuffer);
+  const { width, height } = image.bitmap;
+  if (!width || !height) {
+    throw Error("undefined width or height with url");
+  }
+  const newSize = calculateNewDimensions(width, height);
+  image.resize(newSize.width, newSize.height);
+  const buffer = await image.getBufferAsync(Jimp2.MIME_PNG);
+  return buffer.toString("base64");
+}
+function calculateNewDimensions(originalWidth, originalHeight) {
+  const maxWidth = 768;
+  const maxHeight = 2048;
+  let newWidth = originalWidth;
+  let newHeight = originalHeight;
+  const aspectRatio = originalWidth / originalHeight;
+  if (originalWidth > maxWidth) {
+    newWidth = maxWidth;
+    newHeight = newWidth / aspectRatio;
+  }
+  if (newHeight > maxHeight) {
+    newHeight = maxHeight;
+    newWidth = newHeight * aspectRatio;
+  }
+  return {
+    width: Math.round(newWidth),
+    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
+  };
+}
+
+// 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 colors = [
+      { rect: 65535, text: 4294967295 },
+      // blue, white
+      { rect: 2336560127, text: 4294967295 }
+      // brown, white
+    ];
+    for (let index = 0; index < elements2.length; index++) {
+      const element = elements2[index];
+      const color = colors[index % colors.length];
+      image.scan(
+        element.x,
+        element.y,
+        element.width,
+        element.height,
+        function(x, y, idx) {
+          if (x === element.x || x === element.x + element.width - 1 || y === element.y || y === element.y + element.height - 1) {
+            this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+            this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+            this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
+            this.bitmap.data[idx + 3] = color.rect & 255;
+          }
+        }
+      );
+      const textWidth = element.label.length * 8;
+      const textHeight = 12;
+      const rectWidth = textWidth + 5;
+      const rectHeight = textHeight + 4;
+      let rectX = element.x - rectWidth;
+      let rectY = element.y + element.height / 2 - textHeight / 2 - 2;
+      if (rectX < 0) {
+        rectX = element.x;
+        rectY = element.y - rectHeight;
+      }
+      image.scan(rectX, rectY, rectWidth, rectHeight, function(x, y, idx) {
+        this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+        this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+        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);
+      image.print(
+        font,
+        rectX,
+        rectY,
+        {
+          text: element.label,
+          alignmentX: Jimp3.HORIZONTAL_ALIGN_CENTER,
+          alignmentY: Jimp3.VERTICAL_ALIGN_MIDDLE
+        },
+        rectWidth,
+        rectHeight
+      );
+    }
+    return image.getBufferAsync(Jimp3.MIME_PNG);
+  };
+  return createPngOverlay(elements, imageWidth, imageHeight);
+};
+var processImageElementInfo = async (options) => {
+  const base64Image = options.inputImgBase64.split(";base64,").pop();
+  assert2(base64Image, "base64Image is undefined");
+  const imageBuffer = Buffer3.from(base64Image, "base64");
+  const image = await Jimp3.read(imageBuffer);
+  const { width, height } = image.bitmap;
+  if (width && height) {
+    const svgOverlay = await createSvgOverlay(
+      options.elementsPositionInfo,
+      width,
+      height
+    );
+    const svgOverlayWithoutText = await createSvgOverlay(
+      options.elementsPositionInfoWithoutText,
+      width,
+      height
+    );
+    const compositeElementInfoImgBase64 = await Jimp3.read(imageBuffer).then(async (image2) => {
+      const svgImage = await Jimp3.read(svgOverlay);
+      return image2.composite(svgImage, 0, 0, {
+        mode: Jimp3.BLEND_SOURCE_OVER,
+        opacitySource: 1,
+        opacityDest: 1
+      });
+    }).then((compositeImage) => {
+      return compositeImage.getBufferAsync(Jimp3.MIME_PNG);
+    }).then((buffer) => {
+      return buffer.toString("base64");
+    }).catch((error) => {
+      throw error;
+    });
+    const compositeElementInfoImgWithoutTextBase64 = await Jimp3.read(
+      imageBuffer
+    ).then(async (image2) => {
+      const svgImage = await Jimp3.read(svgOverlayWithoutText);
+      return image2.composite(svgImage, 0, 0, {
+        mode: Jimp3.BLEND_SOURCE_OVER,
+        opacitySource: 1,
+        opacityDest: 1
+      });
+    }).then((compositeImage) => {
+      return compositeImage.getBufferAsync(Jimp3.MIME_PNG);
+    }).then((buffer) => {
+      return buffer.toString("base64");
+    }).catch((error) => {
+      throw error;
+    });
+    return {
+      compositeElementInfoImgBase64,
+      compositeElementInfoImgWithoutTextBase64
+    };
+  }
+  throw Error("Image processing failed because width or height is undefined");
+};
+export {
+  base64Encoded,
+  calculateNewDimensions,
+  imageInfo,
+  imageInfoOfBase64,
+  processImageElementInfo,
+  resizeImg,
+  saveBase64Image,
+  transformImgPathToBase64,
+  trimImage
+};

package/dist/es/index.js

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

package/dist/lib/constants.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/constants/index.ts
+var constants_exports = {};
+__export(constants_exports, {
+  NodeType: () => NodeType,
+  TEXT_MAX_SIZE: () => TEXT_MAX_SIZE,
+  TEXT_SIZE_THRESHOLD: () => TEXT_SIZE_THRESHOLD
+});
+module.exports = __toCommonJS(constants_exports);
+var TEXT_SIZE_THRESHOLD = 9;
+var TEXT_MAX_SIZE = 40;
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2["FORM_ITEM"] = "FORM_ITEM Node";
+  NodeType2["BUTTON"] = "BUTTON Node";
+  NodeType2["IMG"] = "IMG Node";
+  NodeType2["TEXT"] = "TEXT Node";
+  return NodeType2;
+})(NodeType || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeType,
+  TEXT_MAX_SIZE,
+  TEXT_SIZE_THRESHOLD
+});

package/dist/lib/img.js

@@ -0,0 +1,284 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/img/index.ts
+var img_exports = {};
+__export(img_exports, {
+  base64Encoded: () => base64Encoded,
+  calculateNewDimensions: () => calculateNewDimensions,
+  imageInfo: () => imageInfo,
+  imageInfoOfBase64: () => imageInfoOfBase64,
+  processImageElementInfo: () => processImageElementInfo,
+  resizeImg: () => resizeImg,
+  saveBase64Image: () => saveBase64Image,
+  transformImgPathToBase64: () => transformImgPathToBase64,
+  trimImage: () => trimImage
+});
+module.exports = __toCommonJS(img_exports);
+
+// src/img/info.ts
+var import_node_assert = __toESM(require("assert"));
+var import_node_buffer = require("buffer");
+var import_node_fs = require("fs");
+var import_jimp = __toESM(require("jimp"));
+async function imageInfo(image) {
+  let jimpImage;
+  if (typeof image === "string") {
+    jimpImage = await import_jimp.default.read(image);
+  } else if (import_node_buffer.Buffer.isBuffer(image)) {
+    jimpImage = await import_jimp.default.read(image);
+  } else {
+    throw new Error("Invalid image input: must be a string path or a Buffer");
+  }
+  const { width, height } = jimpImage.bitmap;
+  (0, import_node_assert.default)(
+    width && height,
+    `Invalid image: ${typeof image === "string" ? image : "Buffer"}`
+  );
+  return { width, height };
+}
+async function imageInfoOfBase64(imageBase64) {
+  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
+  return imageInfo(import_node_buffer.Buffer.from(base64Data, "base64"));
+}
+function base64Encoded(image, withHeader = true) {
+  const imageBuffer = (0, import_node_fs.readFileSync)(image);
+  if (!withHeader) {
+    return imageBuffer.toString("base64");
+  }
+  if (image.endsWith("png")) {
+    return `data:image/png;base64,${imageBuffer.toString("base64")}`;
+  }
+  if (image.endsWith("jpg") || image.endsWith("jpeg")) {
+    return `data:image/jpeg;base64,${imageBuffer.toString("base64")}`;
+  }
+  throw new Error("unsupported image type");
+}
+
+// src/img/transform.ts
+var import_node_buffer2 = require("buffer");
+var import_jimp2 = __toESM(require("jimp"));
+async function saveBase64Image(options) {
+  const { base64Data, outputPath } = options;
+  const base64Image = base64Data.split(";base64,").pop() || base64Data;
+  const imageBuffer = import_node_buffer2.Buffer.from(base64Image, "base64");
+  const image = await import_jimp2.default.read(imageBuffer);
+  await image.writeAsync(outputPath);
+  console.log("Image successfully written to file.");
+}
+async function transformImgPathToBase64(inputPath) {
+  const image = await import_jimp2.default.read(inputPath);
+  const buffer = await image.getBufferAsync(import_jimp2.default.MIME_PNG);
+  return buffer.toString("base64");
+}
+async function resizeImg(base64Data) {
+  const base64Image = base64Data.split(";base64,").pop() || base64Data;
+  const imageBuffer = import_node_buffer2.Buffer.from(base64Image, "base64");
+  const image = await import_jimp2.default.read(imageBuffer);
+  const { width, height } = image.bitmap;
+  if (!width || !height) {
+    throw Error("undefined width or height with url");
+  }
+  const newSize = calculateNewDimensions(width, height);
+  image.resize(newSize.width, newSize.height);
+  const buffer = await image.getBufferAsync(import_jimp2.default.MIME_PNG);
+  return buffer.toString("base64");
+}
+function calculateNewDimensions(originalWidth, originalHeight) {
+  const maxWidth = 768;
+  const maxHeight = 2048;
+  let newWidth = originalWidth;
+  let newHeight = originalHeight;
+  const aspectRatio = originalWidth / originalHeight;
+  if (originalWidth > maxWidth) {
+    newWidth = maxWidth;
+    newHeight = newWidth / aspectRatio;
+  }
+  if (newHeight > maxHeight) {
+    newHeight = maxHeight;
+    newWidth = newHeight * aspectRatio;
+  }
+  return {
+    width: Math.round(newWidth),
+    height: Math.round(newHeight)
+  };
+}
+async function trimImage(image) {
+  const jimpImage = await import_jimp2.default.read(
+    import_node_buffer2.Buffer.isBuffer(image) ? image : import_node_buffer2.Buffer.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
+var import_node_assert2 = __toESM(require("assert"));
+var import_node_buffer3 = require("buffer");
+var import_jimp3 = __toESM(require("jimp"));
+var createSvgOverlay = (elements, imageWidth, imageHeight) => {
+  const createPngOverlay = async (elements2, imageWidth2, imageHeight2) => {
+    const image = new import_jimp3.default(imageWidth2, imageHeight2, 0);
+    const colors = [
+      { rect: 65535, text: 4294967295 },
+      // blue, white
+      { rect: 2336560127, text: 4294967295 }
+      // brown, white
+    ];
+    for (let index = 0; index < elements2.length; index++) {
+      const element = elements2[index];
+      const color = colors[index % colors.length];
+      image.scan(
+        element.x,
+        element.y,
+        element.width,
+        element.height,
+        function(x, y, idx) {
+          if (x === element.x || x === element.x + element.width - 1 || y === element.y || y === element.y + element.height - 1) {
+            this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+            this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+            this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
+            this.bitmap.data[idx + 3] = color.rect & 255;
+          }
+        }
+      );
+      const textWidth = element.label.length * 8;
+      const textHeight = 12;
+      const rectWidth = textWidth + 5;
+      const rectHeight = textHeight + 4;
+      let rectX = element.x - rectWidth;
+      let rectY = element.y + element.height / 2 - textHeight / 2 - 2;
+      if (rectX < 0) {
+        rectX = element.x;
+        rectY = element.y - rectHeight;
+      }
+      image.scan(rectX, rectY, rectWidth, rectHeight, function(x, y, idx) {
+        this.bitmap.data[idx + 0] = color.rect >> 24 & 255;
+        this.bitmap.data[idx + 1] = color.rect >> 16 & 255;
+        this.bitmap.data[idx + 2] = color.rect >> 8 & 255;
+        this.bitmap.data[idx + 3] = color.rect & 255;
+      });
+      const font = await import_jimp3.default.loadFont(import_jimp3.default.FONT_SANS_16_WHITE);
+      image.print(
+        font,
+        rectX,
+        rectY,
+        {
+          text: element.label,
+          alignmentX: import_jimp3.default.HORIZONTAL_ALIGN_CENTER,
+          alignmentY: import_jimp3.default.VERTICAL_ALIGN_MIDDLE
+        },
+        rectWidth,
+        rectHeight
+      );
+    }
+    return image.getBufferAsync(import_jimp3.default.MIME_PNG);
+  };
+  return createPngOverlay(elements, imageWidth, imageHeight);
+};
+var processImageElementInfo = async (options) => {
+  const base64Image = options.inputImgBase64.split(";base64,").pop();
+  (0, import_node_assert2.default)(base64Image, "base64Image is undefined");
+  const imageBuffer = import_node_buffer3.Buffer.from(base64Image, "base64");
+  const image = await import_jimp3.default.read(imageBuffer);
+  const { width, height } = image.bitmap;
+  if (width && height) {
+    const svgOverlay = await createSvgOverlay(
+      options.elementsPositionInfo,
+      width,
+      height
+    );
+    const svgOverlayWithoutText = await createSvgOverlay(
+      options.elementsPositionInfoWithoutText,
+      width,
+      height
+    );
+    const compositeElementInfoImgBase64 = await import_jimp3.default.read(imageBuffer).then(async (image2) => {
+      const svgImage = await import_jimp3.default.read(svgOverlay);
+      return image2.composite(svgImage, 0, 0, {
+        mode: import_jimp3.default.BLEND_SOURCE_OVER,
+        opacitySource: 1,
+        opacityDest: 1
+      });
+    }).then((compositeImage) => {
+      return compositeImage.getBufferAsync(import_jimp3.default.MIME_PNG);
+    }).then((buffer) => {
+      return buffer.toString("base64");
+    }).catch((error) => {
+      throw error;
+    });
+    const compositeElementInfoImgWithoutTextBase64 = await import_jimp3.default.read(
+      imageBuffer
+    ).then(async (image2) => {
+      const svgImage = await import_jimp3.default.read(svgOverlayWithoutText);
+      return image2.composite(svgImage, 0, 0, {
+        mode: import_jimp3.default.BLEND_SOURCE_OVER,
+        opacitySource: 1,
+        opacityDest: 1
+      });
+    }).then((compositeImage) => {
+      return compositeImage.getBufferAsync(import_jimp3.default.MIME_PNG);
+    }).then((buffer) => {
+      return buffer.toString("base64");
+    }).catch((error) => {
+      throw error;
+    });
+    return {
+      compositeElementInfoImgBase64,
+      compositeElementInfoImgWithoutTextBase64
+    };
+  }
+  throw Error("Image processing failed because width or height is undefined");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  base64Encoded,
+  calculateNewDimensions,
+  imageInfo,
+  imageInfoOfBase64,
+  processImageElementInfo,
+  resizeImg,
+  saveBase64Image,
+  transformImgPathToBase64,
+  trimImage
+});

package/dist/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+function src_default() {
+  return "hello world";
+}

package/dist/types/constants.d.ts

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