@xiuchang-midscene/shared 2.0.2 → 2.0.3

package/dist/es/img/canvas-fallback.mjs.bak

@@ -1,238 +0,0 @@
-import { getDebug } from "../logger.mjs";
-function _define_property(obj, key, value) {
-    if (key in obj) Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-    });
-    else obj[key] = value;
-    return obj;
-}
-const debug = getDebug('img:canvas-fallback');
-class CanvasImage {
-    get_width() {
-        return this._width;
-    }
-    get_height() {
-        return this._height;
-    }
-    get_raw_pixels() {
-        const imageData = this.ctx.getImageData(0, 0, this._width, this._height);
-        return new Uint8Array(imageData.data.buffer);
-    }
-    get_bytes_jpeg(quality) {
-        const dataUrl = this.canvas.toDataURL('image/jpeg', quality / 100);
-        const base64 = dataUrl.split(',')[1];
-        const binary = atob(base64);
-        const bytes = new Uint8Array(binary.length);
-        for(let i = 0; i < binary.length; i++)bytes[i] = binary.charCodeAt(i);
-        return bytes;
-    }
-    free() {}
-    _getCanvas() {
-        return this.canvas;
-    }
-    _getContext() {
-        return this.ctx;
-    }
-    static async new_from_base64(base64Body) {
-        return new Promise((resolve, reject)=>{
-            const img = new Image();
-            img.onload = ()=>{
-                const canvas = document.createElement('canvas');
-                canvas.width = img.width;
-                canvas.height = img.height;
-                const ctx = canvas.getContext('2d');
-                if (!ctx) return void reject(new Error('Failed to get 2d context'));
-                ctx.drawImage(img, 0, 0);
-                resolve(new CanvasImage(canvas));
-            };
-            img.onerror = ()=>{
-                reject(new Error('Failed to load image'));
-            };
-            if (base64Body.startsWith('data:')) img.src = base64Body;
-            else img.src = `data:image/png;base64,${base64Body}`;
-        });
-    }
-    static async new_from_byteslice(bytes) {
-        return new Promise((resolve, reject)=>{
-            const blob = new Blob([
-                bytes
-            ], {
-                type: 'image/png'
-            });
-            const url = URL.createObjectURL(blob);
-            const img = new Image();
-            img.onload = ()=>{
-                const canvas = document.createElement('canvas');
-                canvas.width = img.width;
-                canvas.height = img.height;
-                const ctx = canvas.getContext('2d');
-                if (!ctx) {
-                    URL.revokeObjectURL(url);
-                    reject(new Error('Failed to get 2d context'));
-                    return;
-                }
-                ctx.drawImage(img, 0, 0);
-                URL.revokeObjectURL(url);
-                resolve(new CanvasImage(canvas));
-            };
-            img.onerror = ()=>{
-                URL.revokeObjectURL(url);
-                reject(new Error('Failed to load image from bytes'));
-            };
-            img.src = url;
-        });
-    }
-    constructor(canvas){
-        _define_property(this, "canvas", void 0);
-        _define_property(this, "ctx", void 0);
-        _define_property(this, "_width", void 0);
-        _define_property(this, "_height", void 0);
-        this.canvas = canvas;
-        const ctx = canvas.getContext('2d');
-        if (!ctx) throw new Error('Failed to get 2d context');
-        this.ctx = ctx;
-        this._width = canvas.width;
-        this._height = canvas.height;
-    }
-}
-const CanvasSamplingFilter = {
-    Nearest: 'nearest',
-    Triangle: 'triangle',
-    CatmullRom: 'catmullrom',
-    Gaussian: 'gaussian',
-    Lanczos3: 'lanczos3'
-};
-class CanvasRgba {
-    constructor(r, g, b, a){
-        _define_property(this, "r", void 0);
-        _define_property(this, "g", void 0);
-        _define_property(this, "b", void 0);
-        _define_property(this, "a", void 0);
-        this.r = r;
-        this.g = g;
-        this.b = b;
-        this.a = a;
-    }
-}
-function canvasResize(image, newWidth, newHeight, _filter) {
-    const canvas = document.createElement('canvas');
-    canvas.width = newWidth;
-    canvas.height = newHeight;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.imageSmoothingEnabled = true;
-    ctx.imageSmoothingQuality = 'high';
-    ctx.drawImage(image._getCanvas(), 0, 0, newWidth, newHeight);
-    return new CanvasImage(canvas);
-}
-function canvasCrop(image, x1, y1, x2, y2) {
-    const width = x2 - x1;
-    const height = y2 - y1;
-    const canvas = document.createElement('canvas');
-    canvas.width = width;
-    canvas.height = height;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.drawImage(image._getCanvas(), x1, y1, width, height, 0, 0, width, height);
-    return new CanvasImage(canvas);
-}
-function canvasPaddingRight(image, padding, color) {
-    const newWidth = image.get_width() + padding;
-    const height = image.get_height();
-    const canvas = document.createElement('canvas');
-    canvas.width = newWidth;
-    canvas.height = height;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.fillStyle = `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
-    ctx.fillRect(0, 0, newWidth, height);
-    ctx.drawImage(image._getCanvas(), 0, 0);
-    return new CanvasImage(canvas);
-}
-function canvasPaddingBottom(image, padding, color) {
-    const width = image.get_width();
-    const newHeight = image.get_height() + padding;
-    const canvas = document.createElement('canvas');
-    canvas.width = width;
-    canvas.height = newHeight;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.fillStyle = `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
-    ctx.fillRect(0, 0, width, newHeight);
-    ctx.drawImage(image._getCanvas(), 0, 0);
-    return new CanvasImage(canvas);
-}
-function canvasPaddingUniform(image, padding, color) {
-    const newWidth = image.get_width() + 2 * padding;
-    const newHeight = image.get_height() + 2 * padding;
-    const canvas = document.createElement('canvas');
-    canvas.width = newWidth;
-    canvas.height = newHeight;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.fillStyle = `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
-    ctx.fillRect(0, 0, newWidth, newHeight);
-    ctx.drawImage(image._getCanvas(), padding, padding);
-    return new CanvasImage(canvas);
-}
-function canvasPaddingLeft(image, padding, color) {
-    const newWidth = image.get_width() + padding;
-    const height = image.get_height();
-    const canvas = document.createElement('canvas');
-    canvas.width = newWidth;
-    canvas.height = height;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.fillStyle = `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
-    ctx.fillRect(0, 0, newWidth, height);
-    ctx.drawImage(image._getCanvas(), padding, 0);
-    return new CanvasImage(canvas);
-}
-function canvasPaddingTop(image, padding, color) {
-    const width = image.get_width();
-    const newHeight = image.get_height() + padding;
-    const canvas = document.createElement('canvas');
-    canvas.width = width;
-    canvas.height = newHeight;
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.fillStyle = `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
-    ctx.fillRect(0, 0, width, newHeight);
-    ctx.drawImage(image._getCanvas(), 0, padding);
-    return new CanvasImage(canvas);
-}
-function canvasWatermark(base, overlay, x, y) {
-    const canvas = document.createElement('canvas');
-    canvas.width = base.get_width();
-    canvas.height = base.get_height();
-    const ctx = canvas.getContext('2d');
-    if (!ctx) throw new Error('Failed to get 2d context');
-    ctx.drawImage(base._getCanvas(), 0, 0);
-    ctx.drawImage(overlay._getCanvas(), x, y);
-    return new CanvasImage(canvas);
-}
-function createCanvasFallbackModule() {
-    debug('Creating Canvas fallback module');
-    console.log('[midscene:img] Using Canvas fallback (Photon WASM not available)');
-    return {
-        PhotonImage: CanvasImage,
-        SamplingFilter: CanvasSamplingFilter,
-        resize: canvasResize,
-        crop: canvasCrop,
-        open_image: ()=>{
-            throw new Error('open_image not supported in Canvas fallback');
-        },
-        base64_to_image: CanvasImage.new_from_base64,
-        padding_uniform: canvasPaddingUniform,
-        padding_left: canvasPaddingLeft,
-        padding_right: canvasPaddingRight,
-        padding_top: canvasPaddingTop,
-        padding_bottom: canvasPaddingBottom,
-        watermark: canvasWatermark,
-        Rgba: CanvasRgba
-    };
-}
-export { CanvasImage, CanvasRgba, CanvasSamplingFilter, canvasCrop, canvasPaddingBottom, canvasPaddingLeft, canvasPaddingRight, canvasPaddingTop, canvasPaddingUniform, canvasResize, canvasWatermark, createCanvasFallbackModule };

package/dist/es/img/get-photon.mjs.bak

@@ -1,45 +0,0 @@
-import { getDebug } from "../logger.mjs";
-import { ifInBrowser, ifInNode, ifInWorker } from "../utils.mjs";
-const debug = getDebug('img');
-let photonModule = null;
-let isInitialized = false;
-let usingCanvasFallback = false;
-async function getPhoton() {
-    if (photonModule && isInitialized) return photonModule;
-    const env = ifInBrowser ? 'browser' : ifInWorker ? 'worker' : ifInNode ? 'node' : 'unknown';
-    debug(`Loading photon module in ${env} environment`);
-    try {
-        if (ifInBrowser || ifInWorker) {
-            const photon = await import("@silvia-odwyer/photon");
-            if ('function' == typeof photon.default) await photon.default();
-            debug('Photon loaded: @silvia-odwyer/photon (browser/worker)');
-            photonModule = photon;
-        } else if (ifInNode) {
-            photonModule = await import("@silvia-odwyer/photon-node");
-            debug('Photon loaded: @silvia-odwyer/photon-node (node)');
-        }
-        if (!photonModule?.PhotonImage) throw new Error('PhotonImage is not available');
-        if (!photonModule.PhotonImage.new_from_byteslice && !photonModule.PhotonImage.new_from_base64) throw new Error('PhotonImage.new_from_byteslice or new_from_base64 is not available');
-        isInitialized = true;
-        return photonModule;
-    } catch (error) {
-        debug(`Photon load failed: ${error instanceof Error ? error.message : String(error)}`);
-        if (ifInBrowser) {
-            console.warn(`[midscene:img] Photon WASM failed to load, falling back to Canvas API. Error: ${error instanceof Error ? error.message : String(error)}`);
-            try {
-                const { createCanvasFallbackModule } = await import("./canvas-fallback.mjs");
-                photonModule = createCanvasFallbackModule();
-                usingCanvasFallback = true;
-                isInitialized = true;
-                return photonModule;
-            } catch (fallbackError) {
-                debug(`Canvas fallback also failed: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
-            }
-        }
-        throw new Error(`Failed to load photon module: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function isUsingCanvasFallback() {
-    return usingCanvasFallback;
-}
-export { getPhoton as default, isUsingCanvasFallback };

package/dist/es/img/get-sharp.mjs.bak

@@ -1,11 +0,0 @@
-import { ifInNode } from "../utils.mjs";
-async function getSharp() {
-    if (!ifInNode) throw new Error('Sharp is only available in Node.js environment');
-    try {
-        const sharp = await import("sharp");
-        return sharp.default;
-    } catch (error) {
-        throw new Error(`Failed to load sharp module: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-export { getSharp as default };

package/dist/es/img/index.mjs.bak

@@ -1,4 +0,0 @@
-import { imageInfoOfBase64, isValidImageBuffer, isValidJPEGImageBuffer, isValidPNGImageBuffer } from "./info.mjs";
-import { convertToJpegBase64, createImgBase64ByFormat, cropByRect, httpImg2Base64, localImg2Base64, paddingToMatchBlockByBase64, parseBase64, preProcessImageUrl, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, scaleImage, zoomForGPT4o } from "./transform.mjs";
-import { annotateRects, compositeElementInfoImg, processImageElementInfo } from "./box-select.mjs";
-export { annotateRects, compositeElementInfoImg, convertToJpegBase64, createImgBase64ByFormat, cropByRect, httpImg2Base64, imageInfoOfBase64, isValidImageBuffer, isValidJPEGImageBuffer, isValidPNGImageBuffer, localImg2Base64, paddingToMatchBlockByBase64, parseBase64, preProcessImageUrl, processImageElementInfo, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, scaleImage, zoomForGPT4o };

package/dist/es/img/info.mjs.bak

@@ -1,29 +0,0 @@
-import node_assert from "node:assert";
-import get_photon from "./get-photon.mjs";
-async function imageInfoOfBase64(imageBase64) {
-    const { PhotonImage } = await get_photon();
-    const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, '');
-    const result = PhotonImage.new_from_base64(base64Data);
-    const image = result instanceof Promise ? await result : result;
-    const width = image.get_width();
-    const height = image.get_height();
-    image.free();
-    node_assert(width && height, 'Invalid image: cannot get width or height');
-    return {
-        width,
-        height
-    };
-}
-function isValidPNGImageBuffer(buffer) {
-    if (!buffer || buffer.length < 8) return false;
-    const isPNG = 0x89 === buffer[0] && 0x50 === buffer[1] && 0x4e === buffer[2] && 0x47 === buffer[3] && 0x0d === buffer[4] && 0x0a === buffer[5] && 0x1a === buffer[6] && 0x0a === buffer[7];
-    return isPNG;
-}
-function isValidJPEGImageBuffer(buffer) {
-    if (!buffer || buffer.length < 3) return false;
-    return 0xff === buffer[0] && 0xd8 === buffer[1] && 0xff === buffer[2];
-}
-function isValidImageBuffer(buffer) {
-    return isValidPNGImageBuffer(buffer) || isValidJPEGImageBuffer(buffer);
-}
-export { imageInfoOfBase64, isValidImageBuffer, isValidJPEGImageBuffer, isValidPNGImageBuffer };

package/dist/es/img/transform.mjs.bak

@@ -1,295 +0,0 @@
-import node_assert from "node:assert";
-import { Buffer } from "node:buffer";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import node_path from "node:path";
-import { getDebug } from "../logger.mjs";
-import { ifInNode } from "../utils.mjs";
-import get_photon from "./get-photon.mjs";
-import get_sharp from "./get-sharp.mjs";
-const imgDebug = getDebug('img');
-async function saveBase64Image(options) {
-    const { base64Data, outputPath } = options;
-    const { body } = parseBase64(base64Data);
-    const imageBuffer = Buffer.from(body, 'base64');
-    await writeFile(outputPath, imageBuffer);
-}
-async function resizeAndConvertImgBuffer(inputFormat, inputData, newSize) {
-    if ('string' == typeof inputData) throw Error('inputData is base64, use resizeImgBase64 instead');
-    node_assert(newSize && newSize.width > 0 && newSize.height > 0, 'newSize must be positive');
-    const resizeStartTime = Date.now();
-    imgDebug(`resizeImg start, target size: ${newSize.width}x${newSize.height}`);
-    if (ifInNode) try {
-        const Sharp = await get_sharp();
-        const metadata = await Sharp(inputData).metadata();
-        const { width: originalWidth, height: originalHeight } = metadata;
-        if (!originalWidth || !originalHeight) throw Error('Undefined width or height from the input image.');
-        if (newSize.width === originalWidth && newSize.height === originalHeight) return {
-            buffer: inputData,
-            format: inputFormat
-        };
-        const resizedBuffer = await Sharp(inputData).resize(newSize.width, newSize.height).jpeg({
-            quality: 90
-        }).toBuffer();
-        const resizeEndTime = Date.now();
-        imgDebug(`resizeImg done (Sharp), target size: ${newSize.width}x${newSize.height}, cost: ${resizeEndTime - resizeStartTime}ms`);
-        return {
-            buffer: resizedBuffer,
-            format: 'jpeg'
-        };
-    } catch (error) {
-        imgDebug('Sharp failed, falling back to Photon:', error);
-    }
-    const { PhotonImage, SamplingFilter, resize } = await get_photon();
-    const inputBytes = new Uint8Array(inputData);
-    const bytesliceResult = PhotonImage.new_from_byteslice(inputBytes);
-    const inputImage = bytesliceResult instanceof Promise ? await bytesliceResult : bytesliceResult;
-    const originalWidth = inputImage.get_width();
-    const originalHeight = inputImage.get_height();
-    if (!originalWidth || !originalHeight) {
-        inputImage.free();
-        throw Error('Undefined width or height from the input image.');
-    }
-    if (newSize.width === originalWidth && newSize.height === originalHeight) {
-        inputImage.free();
-        return {
-            buffer: inputData,
-            format: inputFormat
-        };
-    }
-    const outputImage = resize(inputImage, newSize.width, newSize.height, SamplingFilter.CatmullRom);
-    const outputBytes = outputImage.get_bytes_jpeg(90);
-    const resizedBuffer = Buffer.from(outputBytes);
-    inputImage.free();
-    outputImage.free();
-    const resizeEndTime = Date.now();
-    imgDebug(`resizeImg done (Photon), target size: ${newSize.width}x${newSize.height}, cost: ${resizeEndTime - resizeStartTime}ms`);
-    return {
-        buffer: resizedBuffer,
-        format: 'jpeg'
-    };
-}
-const createImgBase64ByFormat = (format, body)=>`data:image/${format};base64,${body}`;
-async function resizeImgBase64(inputBase64, newSize) {
-    const { body, mimeType } = parseBase64(inputBase64);
-    const imageBuffer = Buffer.from(body, 'base64');
-    const { buffer, format } = await resizeAndConvertImgBuffer(mimeType.split('/')[1], imageBuffer, newSize);
-    return createImgBase64ByFormat(format, buffer.toString('base64'));
-}
-function zoomForGPT4o(originalWidth, originalHeight) {
-    const maxWidth = 2048;
-    const maxHeight = 768;
-    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 photonFromBase64(base64) {
-    const { PhotonImage } = await get_photon();
-    const { body } = parseBase64(base64);
-    const result = PhotonImage.new_from_base64(body);
-    return result instanceof Promise ? await result : result;
-}
-async function paddingToMatchBlock(image, blockSize = 28) {
-    const width = image.get_width();
-    const height = image.get_height();
-    const targetWidth = Math.ceil(width / blockSize) * blockSize;
-    const targetHeight = Math.ceil(height / blockSize) * blockSize;
-    if (targetWidth === width && targetHeight === height) return {
-        width,
-        height,
-        image
-    };
-    const { padding_right, padding_bottom, Rgba } = await get_photon();
-    const rightPadding = targetWidth - width;
-    const bottomPadding = targetHeight - height;
-    let result = image;
-    if (rightPadding > 0) {
-        const white = new Rgba(255, 255, 255, 255);
-        result = padding_right(result, rightPadding, white);
-    }
-    if (bottomPadding > 0) {
-        const white = new Rgba(255, 255, 255, 255);
-        const previousResult = result;
-        result = padding_bottom(previousResult, bottomPadding, white);
-        if (previousResult !== image) previousResult.free();
-    }
-    return {
-        width: targetWidth,
-        height: targetHeight,
-        image: result
-    };
-}
-async function paddingToMatchBlockByBase64(imageBase64, blockSize = 28) {
-    const photonImage = await photonFromBase64(imageBase64);
-    try {
-        const paddedResult = await paddingToMatchBlock(photonImage, blockSize);
-        const result = {
-            width: paddedResult.width,
-            height: paddedResult.height,
-            imageBase64: await photonToBase64(paddedResult.image)
-        };
-        if (paddedResult.image !== photonImage) paddedResult.image.free();
-        return result;
-    } finally{
-        photonImage.free();
-    }
-}
-async function cropByRect(imageBase64, rect, paddingImage) {
-    const { crop } = await get_photon();
-    const photonImage = await photonFromBase64(imageBase64);
-    const { left, top, width, height } = rect;
-    const cropped = crop(photonImage, left, top, left + width, top + height);
-    photonImage.free();
-    try {
-        if (paddingImage) {
-            const paddedResult = await paddingToMatchBlock(cropped);
-            const result = {
-                width: paddedResult.width,
-                height: paddedResult.height,
-                imageBase64: await photonToBase64(paddedResult.image)
-            };
-            if (paddedResult.image !== cropped) paddedResult.image.free();
-            return result;
-        }
-        return {
-            width: cropped.get_width(),
-            height: cropped.get_height(),
-            imageBase64: await photonToBase64(cropped)
-        };
-    } finally{
-        cropped.free();
-    }
-}
-async function photonToBase64(image, quality = 90) {
-    const bytes = image.get_bytes_jpeg(quality);
-    const base64Body = Buffer.from(bytes).toString('base64');
-    return `data:image/jpeg;base64,${base64Body}`;
-}
-const httpImg2Base64 = async (url)=>{
-    const response = await fetch(url);
-    if (!response.ok) throw new Error(`Failed to fetch image: ${url}`);
-    const contentType = response.headers.get('content-type');
-    if (!contentType) throw new Error(`Failed to fetch image: ${url}`);
-    node_assert(contentType.startsWith('image/'), `The url ${url} is not a image, because of content-type in header is ${contentType}.`);
-    const buffer = Buffer.from(await response.arrayBuffer());
-    return `data:${contentType};base64,${buffer.toString('base64')}`;
-};
-const localImg2Base64 = (imgPath, withoutHeader = false)=>{
-    const body = readFileSync(imgPath).toString('base64');
-    if (withoutHeader) return body;
-    const type = node_path.extname(imgPath).slice(1);
-    const finalType = 'svg' === type ? 'svg+xml' : type || 'jpg';
-    return `data:image/${finalType};base64,${body}`;
-};
-const preProcessImageUrl = async (url, convertHttpImage2Base64)=>{
-    if ('string' != typeof url) throw new Error(`url must be a string, but got ${url} with type ${typeof url}`);
-    if (url.startsWith('data:')) return url;
-    if (!(url.startsWith('http://') || url.startsWith('https://'))) return await localImg2Base64(url);
-    if (!convertHttpImage2Base64) return url;
-    return await httpImg2Base64(url);
-};
-const parseBase64 = (fullBase64String)=>{
-    try {
-        const separator = ';base64,';
-        const index = fullBase64String.indexOf(separator);
-        if (-1 === index) throw new Error('Invalid base64 string');
-        return {
-            mimeType: fullBase64String.slice(5, index),
-            body: fullBase64String.slice(index + separator.length)
-        };
-    } catch (e) {
-        throw new Error(`parseBase64 fail because intput is not a valid base64 string: ${fullBase64String}`, {
-            cause: e
-        });
-    }
-};
-async function convertToJpegBase64(inputBase64, quality) {
-    const { body } = parseBase64(inputBase64);
-    const buffer = Buffer.from(body, 'base64');
-    if (ifInNode) try {
-        const Sharp = await get_sharp();
-        const jpegBuffer = await Sharp(buffer).jpeg({
-            quality
-        }).toBuffer();
-        return `data:image/jpeg;base64,${jpegBuffer.toString('base64')}`;
-    } catch (error) {
-        imgDebug('Sharp failed for JPEG conversion, falling back to Photon:', error);
-    }
-    const { PhotonImage } = await get_photon();
-    const inputBytes = new Uint8Array(buffer);
-    const bytesliceResult = PhotonImage.new_from_byteslice(inputBytes);
-    const inputImage = bytesliceResult instanceof Promise ? await bytesliceResult : bytesliceResult;
-    const outputBytes = inputImage.get_bytes_jpeg(quality);
-    inputImage.free();
-    return `data:image/jpeg;base64,${Buffer.from(outputBytes).toString('base64')}`;
-}
-async function scaleImage(imageBase64, scale) {
-    if (scale <= 0) throw new Error('Scale factor must be positive');
-    const { body } = parseBase64(imageBase64);
-    const buffer = Buffer.from(body, 'base64');
-    const scaleStartTime = Date.now();
-    imgDebug(`scaleImage start, scale factor: ${scale}`);
-    if (ifInNode) try {
-        const Sharp = await get_sharp();
-        const metadata = await Sharp(buffer).metadata();
-        const originalWidth = metadata.width || 0;
-        const originalHeight = metadata.height || 0;
-        if (0 === originalWidth || 0 === originalHeight) throw new Error('Failed to get image dimensions');
-        const newWidth = Math.round(originalWidth * scale);
-        const newHeight = Math.round(originalHeight * scale);
-        const resizedBuffer = await Sharp(buffer).resize(newWidth, newHeight, {
-            kernel: 'lanczos3',
-            fit: 'fill'
-        }).jpeg({
-            quality: 90
-        }).toBuffer();
-        const scaleEndTime = Date.now();
-        imgDebug(`scaleImage done (Sharp): ${originalWidth}x${originalHeight} -> ${newWidth}x${newHeight} (scale=${scale}), cost: ${scaleEndTime - scaleStartTime}ms`);
-        const base64 = `data:image/jpeg;base64,${resizedBuffer.toString('base64')}`;
-        return {
-            width: newWidth,
-            height: newHeight,
-            imageBase64: base64
-        };
-    } catch (error) {
-        imgDebug('Sharp failed, falling back to Photon:', error);
-    }
-    const { PhotonImage, SamplingFilter, resize } = await get_photon();
-    const inputBytes = new Uint8Array(buffer);
-    const bytesliceResult = PhotonImage.new_from_byteslice(inputBytes);
-    const inputImage = bytesliceResult instanceof Promise ? await bytesliceResult : bytesliceResult;
-    const originalWidth = inputImage.get_width();
-    const originalHeight = inputImage.get_height();
-    if (!originalWidth || !originalHeight) {
-        inputImage.free();
-        throw new Error('Failed to get image dimensions');
-    }
-    const newWidth = Math.round(originalWidth * scale);
-    const newHeight = Math.round(originalHeight * scale);
-    const outputImage = resize(inputImage, newWidth, newHeight, SamplingFilter.CatmullRom);
-    const outputBytes = outputImage.get_bytes_jpeg(90);
-    const resizedBuffer = Buffer.from(outputBytes);
-    inputImage.free();
-    outputImage.free();
-    const scaleEndTime = Date.now();
-    imgDebug(`scaleImage done (Photon): ${originalWidth}x${originalHeight} -> ${newWidth}x${newHeight} (scale=${scale}), cost: ${scaleEndTime - scaleStartTime}ms`);
-    const base64 = `data:image/jpeg;base64,${resizedBuffer.toString('base64')}`;
-    return {
-        width: newWidth,
-        height: newHeight,
-        imageBase64: base64
-    };
-}
-export { convertToJpegBase64, createImgBase64ByFormat, cropByRect, httpImg2Base64, localImg2Base64, paddingToMatchBlock, paddingToMatchBlockByBase64, parseBase64, photonFromBase64, photonToBase64, preProcessImageUrl, resizeAndConvertImgBuffer, resizeImgBase64, saveBase64Image, scaleImage, zoomForGPT4o };

package/dist/es/index.mjs.bak

@@ -1,4 +0,0 @@
-import { createCopyStaticPlugin, createPlaygroundCopyPlugin } from "./build/copy-static.mjs";
-import { commonIgnoreWarnings } from "./build/rspack-config.mjs";
-const src = {};
-export { commonIgnoreWarnings, createCopyStaticPlugin, createPlaygroundCopyPlugin, src as default };