@xiuchang-midscene/shared 2.0.2

package/dist/es/img/transform.mjs

@@ -0,0 +1,295 @@
+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/img/transform.mjs.bak

@@ -0,0 +1,295 @@
+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

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

package/dist/es/index.mjs.bak

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

package/dist/es/logger.mjs

@@ -0,0 +1,64 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import node_util from "node:util";
+import debug from "debug";
+import { getMidsceneRunSubDir } from "./common.mjs";
+import { ifInNode } from "./utils.mjs";
+const topicPrefix = 'midscene';
+const logStreams = new Map();
+const debugInstances = new Map();
+function getLogStream(topic) {
+    const topicFileName = topic.replace(/:/g, '-');
+    if (!logStreams.has(topicFileName)) {
+        const logFile = node_path.join(getMidsceneRunSubDir('log'), `${topicFileName}.log`);
+        const stream = node_fs.createWriteStream(logFile, {
+            flags: 'a'
+        });
+        logStreams.set(topicFileName, stream);
+    }
+    return logStreams.get(topicFileName);
+}
+function writeLogToFile(topic, message) {
+    if (!ifInNode) return;
+    const stream = getLogStream(topic);
+    const now = new Date();
+    const isoDate = now.toLocaleDateString('sv-SE');
+    const isoTime = now.toLocaleTimeString('sv-SE');
+    const milliseconds = now.getMilliseconds().toString().padStart(3, '0');
+    const timezoneOffsetMinutes = now.getTimezoneOffset();
+    const sign = timezoneOffsetMinutes <= 0 ? '+' : '-';
+    const hours = Math.floor(Math.abs(timezoneOffsetMinutes) / 60).toString().padStart(2, '0');
+    const minutes = (Math.abs(timezoneOffsetMinutes) % 60).toString().padStart(2, '0');
+    const timezoneString = `${sign}${hours}:${minutes}`;
+    const localISOTime = `${isoDate}T${isoTime}.${milliseconds}${timezoneString}`;
+    stream.write(`[${localISOTime}] ${message}\n`);
+}
+function getDebug(topic, options) {
+    const fullTopic = `${topicPrefix}:${topic}`;
+    const withConsole = options?.console ?? false;
+    const cacheKey = withConsole ? `${fullTopic}:withConsole` : fullTopic;
+    if (!debugInstances.has(cacheKey)) if (withConsole) {
+        const baseFn = getDebug(topic);
+        const wrapper = (...args)=>{
+            baseFn(...args);
+            console.warn('[Midscene]', ...args);
+        };
+        debugInstances.set(cacheKey, wrapper);
+    } else {
+        const debugFn = debug(fullTopic);
+        const wrapper = (...args)=>{
+            if (ifInNode) {
+                const message = node_util.format(...args);
+                writeLogToFile(topic, message);
+            }
+            debugFn(...args);
+        };
+        debugInstances.set(cacheKey, wrapper);
+    }
+    return debugInstances.get(cacheKey);
+}
+function enableDebug(topic) {
+    if (ifInNode) return;
+    debug.enable(`${topicPrefix}:${topic}`);
+}
+export { enableDebug, getDebug };