@sqaitech/shared 0.5.0

package/dist/lib/img/box-select.js

@@ -0,0 +1,232 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    processImageElementInfo: ()=>processImageElementInfo,
+    compositeElementInfoImg: ()=>compositeElementInfoImg
+});
+const external_node_assert_namespaceObject = require("node:assert");
+var external_node_assert_default = /*#__PURE__*/ __webpack_require__.n(external_node_assert_namespaceObject);
+const external_get_jimp_js_namespaceObject = require("./get-jimp.js");
+var external_get_jimp_js_default = /*#__PURE__*/ __webpack_require__.n(external_get_jimp_js_namespaceObject);
+const external_index_js_namespaceObject = require("./index.js");
+let cachedFont = null;
+const loadFonts = async ()=>{
+    const Jimp = await external_get_jimp_js_default()();
+    try {
+        const fonts = await Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
+        return fonts;
+    } catch (error) {
+        console.warn('Error loading font, will try to load online fonts', error);
+        const onlineFonts = 'https://cdn.jsdelivr.net/npm/jimp-compact@0.16.1-2/fonts/open-sans/open-sans-16-white/open-sans-16-white.fnt';
+        const fonts = await Jimp.loadFont(onlineFonts);
+        return fonts;
+    }
+};
+const createSvgOverlay = async (elements, imageWidth, imageHeight, boxPadding = 5, borderThickness = 2, prompt)=>{
+    const Jimp = await external_get_jimp_js_default()();
+    const image = new Jimp(imageWidth, imageHeight, 0x00000000);
+    const colors = [
+        {
+            rect: 0xc62300ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x0000ffff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x8b4513ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x3e7b27ff,
+            text: 0xffffffff
+        },
+        {
+            rect: 0x500073ff,
+            text: 0xffffffff
+        }
+    ];
+    if (prompt) try {
+        cachedFont = cachedFont || await loadFonts();
+        const promptPadding = 10;
+        const promptMargin = 20;
+        const promptHeight = 30;
+        const promptY = imageHeight - promptHeight - promptMargin;
+        image.scan(0, promptY, imageWidth, promptHeight, (x, y, idx)=>{
+            image.bitmap.data[idx + 0] = 0x00;
+            image.bitmap.data[idx + 1] = 0x00;
+            image.bitmap.data[idx + 2] = 0x00;
+            image.bitmap.data[idx + 3] = 0xcc;
+        });
+        image.print(cachedFont, promptPadding, promptY, {
+            text: prompt,
+            alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
+            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        }, imageWidth - 2 * promptPadding, promptHeight);
+    } catch (error) {
+        console.error('Error drawing prompt text', error);
+    }
+    for(let index = 0; index < elements.length; index++){
+        const element = elements[index];
+        const color = colors[index % colors.length];
+        const paddedLeft = Math.max(0, element.rect.left - boxPadding);
+        const paddedTop = Math.max(0, element.rect.top - boxPadding);
+        const paddedWidth = Math.min(imageWidth - paddedLeft, element.rect.width + 2 * boxPadding);
+        const paddedHeight = Math.min(imageHeight - paddedTop, element.rect.height + 2 * boxPadding);
+        const paddedRect = {
+            left: paddedLeft,
+            top: paddedTop,
+            width: paddedWidth,
+            height: paddedHeight
+        };
+        image.scan(paddedRect.left, paddedRect.top, paddedRect.width, paddedRect.height, (x, y, idx)=>{
+            if (x >= paddedRect.left && x < paddedRect.left + borderThickness || x <= paddedRect.left + paddedRect.width - 1 && x > paddedRect.left + paddedRect.width - borderThickness || y >= paddedRect.top && y < paddedRect.top + borderThickness || y <= paddedRect.top + paddedRect.height - 1 && y > paddedRect.top + paddedRect.height - borderThickness) {
+                image.bitmap.data[idx + 0] = color.rect >> 24 & 0xff;
+                image.bitmap.data[idx + 1] = color.rect >> 16 & 0xff;
+                image.bitmap.data[idx + 2] = color.rect >> 8 & 0xff;
+                image.bitmap.data[idx + 3] = 0xff & color.rect;
+            }
+        });
+        const indexId = element.indexId;
+        if ('number' != typeof indexId) continue;
+        const textWidth = 8 * indexId.toString().length;
+        const textHeight = 12;
+        const rectWidth = textWidth + 5;
+        const rectHeight = textHeight + 4;
+        let rectX = paddedRect.left - rectWidth;
+        let rectY = paddedRect.top + paddedRect.height / 2 - textHeight / 2 - 2;
+        const checkOverlap = (x, y)=>elements.slice(0, index).some((otherElement)=>x < otherElement.rect.left + otherElement.rect.width && x + rectWidth > otherElement.rect.left && y < otherElement.rect.top + otherElement.rect.height && y + rectHeight > otherElement.rect.top);
+        const isWithinBounds = (x, y)=>x >= 0 && x + rectWidth <= imageWidth && y >= 0 && y + rectHeight <= imageHeight;
+        if (checkOverlap(rectX, rectY) || !isWithinBounds(rectX, rectY)) if (!checkOverlap(paddedRect.left, paddedRect.top - rectHeight - 2) && isWithinBounds(paddedRect.left, paddedRect.top - rectHeight - 2)) {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top - rectHeight - 2;
+        } else if (!checkOverlap(paddedRect.left, paddedRect.top + paddedRect.height + 2) && isWithinBounds(paddedRect.left, paddedRect.top + paddedRect.height + 2)) {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top + paddedRect.height + 2;
+        } else if (!checkOverlap(paddedRect.left + paddedRect.width + 2, paddedRect.top) && isWithinBounds(paddedRect.left + paddedRect.width + 2, paddedRect.top)) {
+            rectX = paddedRect.left + paddedRect.width + 2;
+            rectY = paddedRect.top;
+        } else {
+            rectX = paddedRect.left;
+            rectY = paddedRect.top + 2;
+        }
+        image.scan(rectX, rectY, rectWidth, rectHeight, (x, y, idx)=>{
+            image.bitmap.data[idx + 0] = color.rect >> 24 & 0xff;
+            image.bitmap.data[idx + 1] = color.rect >> 16 & 0xff;
+            image.bitmap.data[idx + 2] = color.rect >> 8 & 0xff;
+            image.bitmap.data[idx + 3] = 0xff & color.rect;
+        });
+        try {
+            cachedFont = cachedFont || await loadFonts();
+        } catch (error) {
+            console.error('Error loading font', error);
+        }
+        image.print(cachedFont, rectX, rectY, {
+            text: indexId.toString(),
+            alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
+            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE
+        }, rectWidth, rectHeight);
+    }
+    return image;
+};
+const compositeElementInfoImg = async (options)=>{
+    external_node_assert_default()(options.inputImgBase64, 'inputImgBase64 is required');
+    let width = 0;
+    let height = 0;
+    let jimpImage;
+    const Jimp = await external_get_jimp_js_default()();
+    if (options.size) {
+        width = options.size.width;
+        height = options.size.height;
+    }
+    if (width && height) {
+        const imageBuffer = await (0, external_index_js_namespaceObject.bufferFromBase64)(options.inputImgBase64);
+        jimpImage = await Jimp.read(imageBuffer);
+        const imageBitmap = jimpImage.bitmap;
+        if (imageBitmap.width !== width || imageBitmap.height !== height) jimpImage.resize(width, height, Jimp.RESIZE_NEAREST_NEIGHBOR);
+    } else {
+        const info = await (0, external_index_js_namespaceObject.imageInfoOfBase64)(options.inputImgBase64);
+        width = info.width;
+        height = info.height;
+        jimpImage = info.jimpImage;
+    }
+    if (!width || !height) throw Error('Image processing failed because width or height is undefined');
+    const { elementsPositionInfo, prompt } = options;
+    const result = await Promise.resolve(jimpImage).then(async (image)=>{
+        const svgOverlay = await createSvgOverlay(elementsPositionInfo, width, height, options.annotationPadding, options.borderThickness, prompt);
+        const svgImage = await Jimp.read(svgOverlay);
+        const compositeImage = await image.composite(svgImage, 0, 0, {
+            mode: Jimp.BLEND_SOURCE_OVER,
+            opacitySource: 1,
+            opacityDest: 1
+        });
+        return compositeImage;
+    }).then(async (compositeImage)=>{
+        compositeImage.quality(90);
+        const base64 = await compositeImage.getBase64Async(Jimp.MIME_JPEG);
+        return base64;
+    }).catch((error)=>{
+        throw error;
+    });
+    return result;
+};
+const processImageElementInfo = async (options)=>{
+    const base64Image = options.inputImgBase64.split(';base64,').pop();
+    external_node_assert_default()(base64Image, 'base64Image is undefined');
+    const [compositeElementInfoImgBase64, compositeElementInfoImgWithoutTextBase64] = await Promise.all([
+        compositeElementInfoImg({
+            inputImgBase64: options.inputImgBase64,
+            elementsPositionInfo: options.elementsPositionInfo
+        }),
+        compositeElementInfoImg({
+            inputImgBase64: options.inputImgBase64,
+            elementsPositionInfo: options.elementsPositionInfoWithoutText
+        })
+    ]);
+    return {
+        compositeElementInfoImgBase64,
+        compositeElementInfoImgWithoutTextBase64
+    };
+};
+exports.compositeElementInfoImg = __webpack_exports__.compositeElementInfoImg;
+exports.processImageElementInfo = __webpack_exports__.processImageElementInfo;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "compositeElementInfoImg",
+    "processImageElementInfo"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/img/draw-box.js

@@ -0,0 +1,89 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    drawBoxOnImage: ()=>drawBoxOnImage,
+    savePositionImg: ()=>savePositionImg
+});
+const external_get_jimp_js_namespaceObject = require("./get-jimp.js");
+var external_get_jimp_js_default = /*#__PURE__*/ __webpack_require__.n(external_get_jimp_js_namespaceObject);
+const external_info_js_namespaceObject = require("./info.js");
+const external_transform_js_namespaceObject = require("./transform.js");
+async function drawBoxOnImage(options) {
+    const { inputImgBase64, rect } = options;
+    const color = {
+        r: 255,
+        g: 0,
+        b: 0,
+        a: 255
+    };
+    const Jimp = await external_get_jimp_js_default()();
+    const imageBuffer = await (0, external_info_js_namespaceObject.bufferFromBase64)(inputImgBase64);
+    const image = await Jimp.read(imageBuffer);
+    const centerX = rect.x;
+    const centerY = rect.y;
+    const radius = 5;
+    image.scan(Math.floor(centerX - radius), Math.floor(centerY - radius), 2 * radius, 2 * radius, (x, y, idx)=>{
+        const distance = Math.sqrt((x - centerX) ** 2 + (y - centerY) ** 2);
+        if (distance <= radius) {
+            image.bitmap.data[idx + 0] = color.r;
+            image.bitmap.data[idx + 1] = color.g;
+            image.bitmap.data[idx + 2] = color.b;
+            image.bitmap.data[idx + 3] = color.a;
+        }
+    });
+    image.quality(90);
+    const resultBase64 = await image.getBase64Async(Jimp.MIME_JPEG);
+    return resultBase64;
+}
+async function savePositionImg(options) {
+    const { inputImgBase64, rect, outputPath } = options;
+    const imgBase64 = await drawBoxOnImage({
+        inputImgBase64,
+        rect
+    });
+    await (0, external_transform_js_namespaceObject.saveBase64Image)({
+        base64Data: imgBase64,
+        outputPath
+    });
+}
+exports.drawBoxOnImage = __webpack_exports__.drawBoxOnImage;
+exports.savePositionImg = __webpack_exports__.savePositionImg;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "drawBoxOnImage",
+    "savePositionImg"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/img/get-jimp.js

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_modules__ = {
+    "jimp/browser/lib/jimp.js": function(module) {
+        module.exports = import("jimp/browser/lib/jimp.js").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>getJimp
+    });
+    const external_jimp_namespaceObject = require("jimp");
+    var external_jimp_default = /*#__PURE__*/ __webpack_require__.n(external_jimp_namespaceObject);
+    const external_utils_js_namespaceObject = require("../utils.js");
+    async function getJimp() {
+        if (external_utils_js_namespaceObject.ifInBrowser || external_utils_js_namespaceObject.ifInWorker) {
+            await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "jimp/browser/lib/jimp.js"));
+            return ('undefined' != typeof window ? window : self).Jimp;
+        }
+        return external_jimp_default();
+    }
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/img/get-photon.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_modules__ = {
+    "@silvia-odwyer/photon": function(module) {
+        module.exports = import("@silvia-odwyer/photon").then(function(module) {
+            return module;
+        });
+    },
+    "@silvia-odwyer/photon-node": function(module) {
+        module.exports = import("@silvia-odwyer/photon-node").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>getPhoton
+    });
+    const external_utils_js_namespaceObject = require("../utils.js");
+    let photonModule = null;
+    let isInitialized = false;
+    async function getPhoton() {
+        if (photonModule && isInitialized) return photonModule;
+        try {
+            if (external_utils_js_namespaceObject.ifInBrowser || external_utils_js_namespaceObject.ifInWorker) {
+                const photon = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@silvia-odwyer/photon"));
+                if ('function' == typeof photon.default) await photon.default();
+                photonModule = photon;
+            } else if (external_utils_js_namespaceObject.ifInNode) photonModule = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@silvia-odwyer/photon-node"));
+            if (!photonModule.PhotonImage || !photonModule.PhotonImage.new_from_byteslice) throw new Error('PhotonImage.new_from_byteslice is not available');
+            isInitialized = true;
+            return photonModule;
+        } catch (error) {
+            throw new Error(`Failed to load photon module: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/img/get-sharp.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_modules__ = {
+    sharp: function(module) {
+        module.exports = import("sharp").then(function(module) {
+            return module;
+        });
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>getSharp
+    });
+    const external_utils_js_namespaceObject = require("../utils.js");
+    async function getSharp() {
+        if (!external_utils_js_namespaceObject.ifInNode) throw new Error('Sharp is only available in Node.js environment');
+        try {
+            const sharp = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "sharp"));
+            return sharp.default;
+        } catch (error) {
+            throw new Error(`Failed to load sharp module: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/img/index.js

@@ -0,0 +1,102 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    localImg2Base64: ()=>external_transform_js_namespaceObject.localImg2Base64,
+    compositeElementInfoImg: ()=>external_box_select_js_namespaceObject.compositeElementInfoImg,
+    isValidPNGImageBuffer: ()=>external_info_js_namespaceObject.isValidPNGImageBuffer,
+    saveBase64Image: ()=>external_transform_js_namespaceObject.saveBase64Image,
+    zoomForGPT4o: ()=>external_transform_js_namespaceObject.zoomForGPT4o,
+    jimpToBase64: ()=>external_transform_js_namespaceObject.jimpToBase64,
+    bufferFromBase64: ()=>external_info_js_namespaceObject.bufferFromBase64,
+    drawBoxOnImage: ()=>external_draw_box_js_namespaceObject.drawBoxOnImage,
+    paddingToMatchBlockByBase64: ()=>external_transform_js_namespaceObject.paddingToMatchBlockByBase64,
+    resizeImgBase64: ()=>external_transform_js_namespaceObject.resizeImgBase64,
+    paddingToMatchBlock: ()=>external_transform_js_namespaceObject.paddingToMatchBlock,
+    savePositionImg: ()=>external_draw_box_js_namespaceObject.savePositionImg,
+    imageInfoOfBase64: ()=>external_info_js_namespaceObject.imageInfoOfBase64,
+    cropByRect: ()=>external_transform_js_namespaceObject.cropByRect,
+    resizeAndConvertImgBuffer: ()=>external_transform_js_namespaceObject.resizeAndConvertImgBuffer,
+    createImgBase64ByFormat: ()=>external_transform_js_namespaceObject.createImgBase64ByFormat,
+    httpImg2Base64: ()=>external_transform_js_namespaceObject.httpImg2Base64,
+    parseBase64: ()=>external_transform_js_namespaceObject.parseBase64,
+    processImageElementInfo: ()=>external_box_select_js_namespaceObject.processImageElementInfo,
+    jimpFromBase64: ()=>external_transform_js_namespaceObject.jimpFromBase64,
+    imageInfo: ()=>external_info_js_namespaceObject.imageInfo,
+    preProcessImageUrl: ()=>external_transform_js_namespaceObject.preProcessImageUrl
+});
+const external_info_js_namespaceObject = require("./info.js");
+const external_transform_js_namespaceObject = require("./transform.js");
+const external_box_select_js_namespaceObject = require("./box-select.js");
+const external_draw_box_js_namespaceObject = require("./draw-box.js");
+exports.bufferFromBase64 = __webpack_exports__.bufferFromBase64;
+exports.compositeElementInfoImg = __webpack_exports__.compositeElementInfoImg;
+exports.createImgBase64ByFormat = __webpack_exports__.createImgBase64ByFormat;
+exports.cropByRect = __webpack_exports__.cropByRect;
+exports.drawBoxOnImage = __webpack_exports__.drawBoxOnImage;
+exports.httpImg2Base64 = __webpack_exports__.httpImg2Base64;
+exports.imageInfo = __webpack_exports__.imageInfo;
+exports.imageInfoOfBase64 = __webpack_exports__.imageInfoOfBase64;
+exports.isValidPNGImageBuffer = __webpack_exports__.isValidPNGImageBuffer;
+exports.jimpFromBase64 = __webpack_exports__.jimpFromBase64;
+exports.jimpToBase64 = __webpack_exports__.jimpToBase64;
+exports.localImg2Base64 = __webpack_exports__.localImg2Base64;
+exports.paddingToMatchBlock = __webpack_exports__.paddingToMatchBlock;
+exports.paddingToMatchBlockByBase64 = __webpack_exports__.paddingToMatchBlockByBase64;
+exports.parseBase64 = __webpack_exports__.parseBase64;
+exports.preProcessImageUrl = __webpack_exports__.preProcessImageUrl;
+exports.processImageElementInfo = __webpack_exports__.processImageElementInfo;
+exports.resizeAndConvertImgBuffer = __webpack_exports__.resizeAndConvertImgBuffer;
+exports.resizeImgBase64 = __webpack_exports__.resizeImgBase64;
+exports.saveBase64Image = __webpack_exports__.saveBase64Image;
+exports.savePositionImg = __webpack_exports__.savePositionImg;
+exports.zoomForGPT4o = __webpack_exports__.zoomForGPT4o;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "bufferFromBase64",
+    "compositeElementInfoImg",
+    "createImgBase64ByFormat",
+    "cropByRect",
+    "drawBoxOnImage",
+    "httpImg2Base64",
+    "imageInfo",
+    "imageInfoOfBase64",
+    "isValidPNGImageBuffer",
+    "jimpFromBase64",
+    "jimpToBase64",
+    "localImg2Base64",
+    "paddingToMatchBlock",
+    "paddingToMatchBlockByBase64",
+    "parseBase64",
+    "preProcessImageUrl",
+    "processImageElementInfo",
+    "resizeAndConvertImgBuffer",
+    "resizeImgBase64",
+    "saveBase64Image",
+    "savePositionImg",
+    "zoomForGPT4o"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});