@midscene/shared 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/lib/img.js

@@ -26,12 +26,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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/index.ts
 var img_exports = {};
 __export(img_exports, {
   base64Encoded: () => base64Encoded,
   base64ToPngFormat: () => base64ToPngFormat,
+  bufferFromBase64: () => bufferFromBase64,
   calculateNewDimensions: () => calculateNewDimensions,
   compositeElementInfoImg: () => compositeElementInfoImg,
   imageInfo: () => imageInfo,
@@ -48,26 +69,49 @@ module.exports = __toCommonJS(img_exports);
 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 };
+
+// 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(import_node_buffer.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 (import_node_buffer.Buffer.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;
+    (0, import_node_assert.default)(
+      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 import_node_buffer.Buffer.from(base64Data, "base64");
+  });
 }
 function base64Encoded(image, withHeader = true) {
   const imageBuffer = (0, import_node_fs.readFileSync)(image);
@@ -88,31 +132,39 @@ function base64ToPngFormat(base64) {
 
 // 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);
+function saveBase64Image(options) {
+  return __async(this, null, function* () {
+    const { base64Data, outputPath } = options;
+    const base64Image = base64Data.split(";base64,").pop() || base64Data;
+    const imageBuffer = import_node_buffer2.Buffer.from(base64Image, "base64");
+    const Jimp = yield getJimp();
+    const image = yield Jimp.read(imageBuffer);
+    yield image.writeAsync(outputPath);
+  });
 }
-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");
+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 ? import_node_buffer2.Buffer.from(inputData.split(";base64,").pop() || inputData, "base64") : inputData;
-  const image = await import_jimp2.default.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(import_jimp2.default.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 ? import_node_buffer2.Buffer.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;
@@ -133,36 +185,38 @@ function calculateNewDimensions(originalWidth, originalHeight) {
     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
-  };
+function trimImage(image) {
+  return __async(this, null, function* () {
+    const Jimp = yield getJimp();
+    const jimpImage = yield Jimp.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 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
@@ -243,59 +297,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 import_jimp3.default.loadFont(import_jimp3.default.FONT_SANS_16_WHITE);
+      const font = yield Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
       image.print(
         font,
         rectX,
         rectY,
         {
           text: element.indexId.toString(),
-          alignmentX: import_jimp3.default.HORIZONTAL_ALIGN_CENTER,
-          alignmentY: import_jimp3.default.VERTICAL_ALIGN_MIDDLE
+          alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+          alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
         },
         rectWidth,
         rectHeight
       );
     }
-    return image.getBufferAsync(import_jimp3.default.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 = import_node_buffer3.Buffer.from(inputImgBase64, "base64");
-  const image = await import_jimp3.default.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 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,
+  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(import_jimp3.default.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();
   (0, import_node_assert2.default)(base64Image, "base64Image is undefined");
   const [
     compositeElementInfoImgBase64,
     compositeElementInfoImgWithoutTextBase64
-  ] = await Promise.all([
+  ] = yield Promise.all([
     compositeElementInfoImg({
       inputImgBase64: options.inputImgBase64,
       elementsPositionInfo: options.elementsPositionInfo
@@ -309,11 +363,12 @@ var processImageElementInfo = async (options) => {
     compositeElementInfoImgBase64,
     compositeElementInfoImgWithoutTextBase64
   };
-};
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   base64Encoded,
   base64ToPngFormat,
+  bufferFromBase64,
   calculateNewDimensions,
   compositeElementInfoImg,
   imageInfo,

package/dist/lib/index.d.ts

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

package/dist/lib/index.js

@@ -23,6 +23,4 @@ __export(src_exports, {
   default: () => src_default
 });
 module.exports = __toCommonJS(src_exports);
-function src_default() {
-  return "hello world";
-}
+var src_default = {};

package/dist/lib/utils.d.ts

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

package/dist/lib/utils.js

@@ -0,0 +1,39 @@
+"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/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ifInBrowser: () => ifInBrowser,
+  uuid: () => uuid
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_crypto = require("crypto");
+var ifInBrowser = typeof window !== "undefined";
+function uuid() {
+  if (ifInBrowser) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  return (0, import_node_crypto.randomUUID)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ifInBrowser,
+  uuid
+});

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
-declare function export_default(): string;
+declare const _default: {};
 
-export { export_default as default };
+export { _default as default };

package/package.json

@@ -1,46 +1,70 @@
 {
   "name": "@midscene/shared",
-  "version": "0.7.1",
+  "version": "0.7.2-beta-20241024094141.0",
   "repository": "https://github.com/web-infra-dev/midscene",
   "homepage": "https://midscenejs.com/",
-  "types": "./dist/types/index.d.ts",
+  "types": "./src/index.ts",
+  "type": "commonjs",
   "main": "./dist/lib/index.js",
   "module": "./dist/es/index.js",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": "./dist/lib/index.d.ts",
+      "require": "./dist/lib/index.js",
       "import": "./dist/es/index.js",
-      "require": "./dist/lib/index.js"
+      "browser": "./dist/browser/index.js"
     },
     "./constants": {
-      "types": "./dist/types/constants.d.ts",
+      "types": "./dist/lib/constants.d.ts",
+      "require": "./dist/lib/constants.js",
       "import": "./dist/es/constants.js",
-      "require": "./dist/lib/constants.js"
+      "browser": "./dist/browser/constants.js"
+    },
+    "./fs": {
+      "types": "./dist/lib/fs.d.ts",
+      "require": "./dist/lib/fs.js",
+      "import": "./dist/es/fs.js",
+      "browser": "./dist/browser/fs.js"
     },
     "./img": {
-      "types": "./dist/types/img.d.ts",
+      "types": "./dist/lib/img.d.ts",
+      "require": "./dist/lib/img.js",
       "import": "./dist/es/img.js",
-      "require": "./dist/lib/img.js"
+      "browser": "./dist/browser/img.js"
     },
-    "./fs": {
-      "types": "./dist/types/fs.d.ts",
-      "import": "./dist/es/fs.js",
-      "require": "./dist/lib/fs.js"
-    }
+    "./utils": {
+      "types": "./dist/lib/utils.d.ts",
+      "require": "./dist/lib/utils.js",
+      "import": "./dist/es/utils.js",
+      "browser": "./dist/browser/utils.js"
+    },
+    "./browser": "./dist/browser/index.js",
+    "./browser/constants": "./dist/browser/constants.js",
+    "./browser/fs": "./dist/browser/fs.js",
+    "./browser/img": "./dist/browser/img.js",
+    "./browser/utils": "./dist/browser/utils.js"
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/types/index.d.ts"
+        "./src/index.ts"
       ],
       "constants": [
-        "./dist/types/constants.d.ts"
+        "./src/constants/index.ts"
       ],
       "img": [
-        "./dist/types/img.d.ts"
+        "./src/img/index.ts"
       ],
       "fs": [
-        "./dist/types/fs.d.ts"
+        "./src/fs/index.ts"
+      ],
+      "utils": [
+        "./src/utils.ts"
+      ]
+    },
+    "./browser": {
+      "*": [
+        "./dist/browser/*"
       ]
     }
   },

package/src/fs/index.ts

@@ -9,7 +9,11 @@ interface PkgInfo {
 }
 
 let pkg: PkgInfo | undefined;
-export function getMidscenePkgInfo(dir: string): PkgInfo {
+const ifInBrowser = typeof window !== 'undefined';
+export function getRunningPkgInfo(dir?: string): PkgInfo | null {
+  if (ifInBrowser) {
+    return null;
+  }
   if (pkg) {
     return pkg;
   }
@@ -24,7 +28,7 @@ export function getMidscenePkgInfo(dir: string): PkgInfo {
     return pkg;
   }
   return {
-    name: 'midscene-unknown-page-name',
+    name: 'midscene-unknown-package-name',
     version: '0.0.0',
     dir: pkgDir,
   };

package/src/img/box-select.ts

@@ -1,8 +1,10 @@
 import assert from 'node:assert';
-import { Buffer } from 'node:buffer';
+import type { Buffer } from 'node:buffer';
 import type { Rect } from '@/types';
-import Jimp from 'jimp';
+import type Jimp from 'jimp';
 import type { NodeType } from '../constants';
+import getJimp from './get-jimp';
+import { bufferFromBase64, imageInfo } from './index';
 
 // Define picture path
 type ElementType = {
@@ -32,6 +34,7 @@ const createSvgOverlay = (
     imageWidth: number,
     imageHeight: number,
   ) => {
+    const Jimp = await getJimp();
     const image = new Jimp(imageWidth, imageHeight, 0x00000000);
 
     // Define color array
@@ -192,10 +195,10 @@ export const compositeElementInfoImg = async (options: {
   inputImgBase64: string;
   elementsPositionInfo: Array<ElementType>;
 }) => {
+  const Jimp = await getJimp();
   const { inputImgBase64, elementsPositionInfo } = options;
-  const imageBuffer = Buffer.from(inputImgBase64, 'base64');
-  const image = await Jimp.read(imageBuffer);
-  const { width, height } = image.bitmap;
+  const imageBuffer = await bufferFromBase64(inputImgBase64);
+  const { width, height } = await imageInfo(imageBuffer);
 
   if (!width || !height) {
     throw Error('Image processing failed because width or height is undefined');

package/src/img/get-jimp.ts

@@ -0,0 +1,7 @@
+const ifInBrowser = typeof window !== 'undefined';
+export default async function getJimp(): Promise<typeof import('jimp')> {
+  if (ifInBrowser) {
+    return (await import('jimp/browser/lib/jimp.js')).default;
+  }
+  return (await import('jimp')).default;
+}

package/src/img/index.ts

@@ -1,6 +1,7 @@
 export {
   imageInfo,
   imageInfoOfBase64,
+  bufferFromBase64,
   base64Encoded,
   base64ToPngFormat,
 } from './info';

package/src/img/info.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert';
 import { Buffer } from 'node:buffer';
 import { readFileSync } from 'node:fs';
-import Jimp from 'jimp';
+import getJimp from './get-jimp';
 
 export interface Size {
   width: number;
@@ -16,7 +16,8 @@ export interface Size {
  * @throws Error if the image data is invalid
  */
 export async function imageInfo(image: string | Buffer): Promise<Size> {
-  let jimpImage: Jimp;
+  const Jimp = await getJimp();
+  let jimpImage;
   if (typeof image === 'string') {
     jimpImage = await Jimp.read(image);
   } else if (Buffer.isBuffer(image)) {
@@ -40,9 +41,15 @@ export async function imageInfo(image: string | Buffer): Promise<Size> {
  * @throws Error if the image data is invalid
  */
 export async function imageInfoOfBase64(imageBase64: string): Promise<Size> {
-  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, '');
+  // const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, '');
   // Call the imageInfo function to get the dimensions of the image
-  return imageInfo(Buffer.from(base64Data, 'base64'));
+  const buffer = await bufferFromBase64(imageBase64);
+  return imageInfo(buffer);
+}
+
+export async function bufferFromBase64(imageBase64: string): Promise<Buffer> {
+  const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, '');
+  return Buffer.from(base64Data, 'base64');
 }
 
 /**

package/src/img/jimp.d.ts

@@ -0,0 +1,4 @@
+declare module 'jimp/browser/lib/jimp.js' {
+  import Jimp from 'jimp';
+  export default Jimp;
+}

package/src/img/transform.ts

@@ -1,6 +1,7 @@
 import { Buffer } from 'node:buffer';
-import Jimp from 'jimp';
+import getJimp from './get-jimp';
 
+/**
 /**
  * Saves a Base64-encoded image to a file
  *
@@ -21,6 +22,7 @@ export async function saveBase64Image(options: {
   const imageBuffer = Buffer.from(base64Image, 'base64');
 
   // Use Jimp to process the image and save it to the specified location
+  const Jimp = await getJimp();
   const image = await Jimp.read(imageBuffer);
   await image.writeAsync(outputPath);
 }
@@ -32,6 +34,7 @@ export async function saveBase64Image(options: {
  */
 export async function transformImgPathToBase64(inputPath: string) {
   // Use Jimp to process images and generate base64 data
+  const Jimp = await getJimp();
   const image = await Jimp.read(inputPath);
   const buffer = await image.getBufferAsync(Jimp.MIME_PNG);
   return buffer.toString('base64');
@@ -56,6 +59,7 @@ export async function resizeImg(
     ? Buffer.from(inputData.split(';base64,').pop() || inputData, 'base64')
     : inputData;
 
+  const Jimp = await getJimp();
   const image = await Jimp.read(imageBuffer);
   const { width, height } = image.bitmap;
 
@@ -127,6 +131,7 @@ export async function trimImage(image: string | Buffer): Promise<{
   width: number;
   height: number;
 } | null> {
+  const Jimp = await getJimp();
   const jimpImage = await Jimp.read(
     Buffer.isBuffer(image) ? image : Buffer.from(image),
   );

package/src/index.ts

@@ -1,3 +1 @@
-export default function () {
-  return 'hello world';
-}
+export default {};

package/src/utils.ts

@@ -0,0 +1,10 @@
+import { randomUUID } from 'node:crypto';
+
+export const ifInBrowser = typeof window !== 'undefined';
+
+export function uuid() {
+  if (ifInBrowser) {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  return randomUUID();
+}