@ohos-ports/applitools-image 1.3.2-beta.1

package/LICENSE

@@ -0,0 +1,26 @@
+-  -
+SDK LICENSE AGREEMENT
+IMPORTANT - PLEASE READ CAREFULLY THE TERMS OF THIS LICENSE AGREEMENT (“AGREEMENT”). BY INSTALLING, ACCESSING AND/OR USING THE SOFTWARE (AS DEFINED BELOW), YOU EXPRESSLY ACKNOWLEDGE AND AGREE THAT YOU, OR THE COMPANY YOU REPRESENT, (“YOU” OR “LICENSEE”) ARE ENTERING INTO A LEGAL AGREEMENT WITH APPLITOOLS LTD. AND ITS AFFILIATES (“APPLITOOLS”), AND HAVE UNDERSTOOD AND AGREE TO COMPLY WITH, AND BE LEGALLY BOUND BY, THE TERMS AND CONDITIONS OF THIS AGREEMENT. YOU HEREBY WAIVE ANY RIGHTS OR REQUIREMENTS UNDER ANY LAWS OR REGULATIONS IN ANY JURISDICTION WHICH REQUIRE AN ORIGINAL (NON-ELECTRONIC) SIGNATURE OR DELIVERY OR RETENTION OF NON-ELECTRONIC RECORDS, TO THE EXTENT PERMITTED UNDER APPLICABLE LAW. 
+THE SOFTWARE MAY BE USED SOLELY FOR YOUR PERSONAL, NON-COMMERCIAL PURPOSES. FOR COMMERCIAL PURPOSES PLEASE CONTACT THE REGIONAL APPLITOOLS BUSINESS REPRESENTATIVE. 
+1. Definitions. For purposes of this Agreement, the following capitalized terms shall have the following meaning:
+   1. “Documentation” means the user’s guides and technical manuals delivered by Applitools to Licensee.
+   2.  “Feedback” means suggestions, comments or feedback (whether orally or in writing) with respect to the Software.
+   3. “Intellectual Property Rights” means all intangible legal rights, titles and interests evidenced by or embodied in all: (i) inventions (regardless of patentability and whether or not reduced to practice), improvements thereto, patents, patent applications, patent disclosures, together with all reissuances, continuations, continuations in part, revisions, extensions and reexaminations thereof; (ii) trademarks, service marks, trade dress, logos, trade names, corporate names, together with translations, adaptations, derivations and combinations thereof, including goodwill associated therewith, and applications, registrations, and renewals in connection therewith; (iii) any work of authorship, regardless of copyrightable, copyrightable works, copyrights (including moral rights), and applications, registrations and renewals in connection therewith; (iv) mask works and applications, registrations and renewals in connection therewith; (v) trade secrets and Confidential Information; and (vi) other proprietary rights and any other similar rights, in each case on a worldwide basis, and copies and tangible embodiments thereof, in whatever form or medium.
+   4. “License” means the right to use the Software pursuant to Section ‎2.1 to this Agreement.
+   5.  “Software” means Applitools’ software development kit software in object or source code version, Documentation and any updates and upgrade thereto (to the extent delivered).
+1. License
+   1. Grant of License. Subject to the terms and conditions of this Agreement, Applitools grants You, during the Term, a personal, non-exclusive, non-sublicensable, non-transferable, revocable license to: (i) use the Software solely for Your own personal (non-commercial) use and (ii) use and display Applitools’ Marks solely for the purpose of publicizing or advertising that You are using the Software. 
+   2. Documentation. Applitools may make available Documentation to Licensee for Licensee to use solely in connection with Licensee’s use of the Software during the term of this Agreement. Licensee may print or copy the Documentation as needed for its own purposes provided that all copyright notices are included therein. The Documentation shall be considered the Confidential Information of Applitools. 
+   1. Reservation of Rights; Use Restrictions. Other than the rights explicitly granted in this Agreement, Licensee shall have no other rights, express or implied, in the Software. Without limiting the generality of the foregoing, Licensee agrees and undertakes not to: (i) allow any third party to use the Software in any manner, including but not limited to, sell, lease, sublicense or distribute the Software, or any part thereof; (ii) modify, revise, or alter the Software or reverse engineer, decompile, disassemble or otherwise reduce to human-perceivable form the Software’s source code; (iii) copy or allow copies of the Software to be made; (iv) remove, alter or obscure any proprietary notice or identification, including copyright, trademark, patent or other notices, contained in or displayed on or via the Software; (v) use the Software to violate any applicable laws, rules or regulations, or for any unlawful, harmful, irresponsible, or inappropriate purpose, or in any manner that breaches this Agreement, and/or (vi) represent that it possesses any proprietary interest in the Software.
+   1. Third Party Software. Licensee acknowledges and agrees that any third party software (“Third Party Software”) that provided with the Software is provided under the terms of the license attached/linked thereto or, if no such license is attached, such Third Party Software is provided for free and on “AS IS” basis. Applitools is not liable for any losses or damages which may occur resulting from the use of any Third Party Software. Applitools does not possess any proprietary interest in such Third Party Software. 
+   1. Open Source Licenses. The Software includes certain open source code software and materials (as shall be listed in the documentation of the Software) (“Open Source Software”) that are subject to their respective open source licenses (“Open Source Licenses”). Such Open Source Licenses contain a list of conditions with respect to warranty, copyright policy and other provisions. By executing this Agreement, Licensee undertakes to strictly comply with the terms and condition of the Open Source Licenses, as may be amended from time to time. In order to comply with the Open Source Licenses, Licensee shall read the respective licenses or notices, such list of Open Source Licenses may be amended from time to time by Applitools, at its sole discretion. In the event of any inconsistencies or conflicting provisions between the provisions of the Open Source Licenses and the provisions of this Agreement, the provisions of the Open Source Licenses shall prevail. Without derogating from the generality of the foregoing, it is clarified that any Open Source Software is provided on an “AS IS” basis, without indemnity or warranty of any kind, whether express or implied. For clarity, the representations and warranties set forth in Section ‎4 hereunder shall not apply to any Open Source Software.
+1. Title & Ownership. APPLITOOLS DOES NOT SELL OR TRANSFER TITLE IN THE SOFTWARE, OR ANY PART THEREOF, TO LICENSEE. The Documentation, Software (excluding any Open Source Software and Third Party Software therein which are owned by their respective licensors) and/or any copies thereof, including without limitation any derivative works made (regardless of whether such derivative works were made and/or developed pursuant to the request and/or specifications of Licensee, and irrespective of any support and/or assistance Applitools may, will or had received from Licensee, or any third party on its behalf, with respect thereto), as well as any updates or upgrades thereto, if provided to Applitools pursuant to this Agreement, shall remain Applitools’ sole and exclusive property. All Intellectual Property Rights evidenced by or embodied in and/or attached/connected/related to the Software, or part thereof, are and shall be owned solely and exclusively by Applitools. Nothing in this Agreement shall constitute a waiver of Applitools’ Intellectual Property Rights under any law, or be in any way construed or interpreted as such. It is further agreed that to the extent Licensee provides Applitools with Feedback, Licensee acknowledges that any and all rights, including Intellectual Property Rights in such Feedback shall belong exclusively to Applitools and Licensee hereby irrevocably and unconditionally transfers and assigns to Applitools all intellectual property rights in such Feedback and waives any and all moral rights that Licensee may have in respect thereto. It is further understood that use of Feedback, if any, may be made by Applitools at its sole discretion, and that Applitools in no way shall be obliged to make use of any kind of the Feedback or part thereof. 
+1. Warranty. Applitools warrants that to its knowledge it has the right to grant the license under this Agreement. Applitools’ sole liability for any breach of this warranty or any other warranty under this Agreement shall be, at Applitools’ sole discretion: (i) to replace or repair the Software or the applicable portion thereof; or (ii) to terminate this Agreement.
+2. Warranty Exclusions. The warranties set forth in Section ‎4 are contingent upon Licensee’s proper use of the Software, and shall not apply to damage caused by abuse, misuse, alteration, neglect or unauthorized repair or installation, or by the use or attempted use of Software other than that supplied and supported by Applitools. Applitools will use reasonable commercial efforts to repair or replace the Software or the applicable portion thereof, pursuant to the foregoing warranty within thirty (30) days of being so notified.
+1. Warranty Disclaimers. AS BETWEEN LICENSEE AND APPLITOOLS, EXCEPT AS SET IN SECTION ‎4, THE SOFTWARE IS PROVIDED ON AN “AS IS” AND “AS AVAILABLE” BASIS WITHOUT WARRANTIES OF ANY KIND INCLUDING, WITHOUT LIMITATION, REPRESENTATIONS, WARRANTIES AND CONDITIONS OF MERCHANTABILITY, FITNESS FOR INTENDED OR PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, THAT THE SOFTWARE WILL MEET LICENSEE’S REQUIREMENTS OR EXPECTATIONS OR WILL ACHIEVE ANY SPECIFIC RESULTS AND THOSE ARISING BY STATUTE OR FROM A COURSE OF DEALING OR USAGE OF TRADE. Applicable law may not allow the exclusion of certain warranties, so to that extent such exclusions may not apply.
+1. High Risk Activities. You acknowledge that the Software is not fault tolerant and is not designed, manufactured, or intended for use or resale as on-line control equipment in hazardous or high risk environments and activities requiring fail-safe performance (such as in the operation of nuclear facilities, aircraft navigation or communication systems, air traffic control, direct life support machines and/or devices, or weapons systems) in which the failure of the Software could lead directly to death, personal injury, or severe physical or environmental damage, and You agree not to use or allow the use of the Software or any portion thereof for, or in connection with, any such environment or activity.
+1. Indemnify. You agree that Applitools shall have no liability whatsoever for any use made of the Software by You or any third party. You hereby agree to defend, indemnify and hold harmless Applitools and its affiliates and their respective officers, directors, agents and employees from any and all claims, damages, liabilities, costs, and expenses (including attorney’s fees) arising from claims related to Your use of the Software as well as from Your failure to comply with this Agreement.
+1. Limitation of Liability. UNDER NO CIRCUMSTANCES SHALL APPLITOOLS AND/OR ITS AFFILIATES BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR FOR ANY LOSS OF DATA, REVENUE, BUSINESS OR REPUTATION, THAT ARISES UNDER OR IN CONNECTION WITH THIS AGREEMENT, OR THAT RESULTS FROM THE USE OF, OR THE INABILITY TO USE, THE SOFTWARE. APPLITOOLS’S TOTAL AGGREGATE LIABILITY FOR ANY AND ALL DIRECT DAMAGES AND LOSSES THAT ARISE UNDER OR IN CONNECTION WITH THIS AGREEMENT SHALL NOT IN ANY CIRCUMSTANCE EXCEED THE AMOUNT OF 100.00 (ONE HUNDRED) UNITED STATES DOLLARS. THE FOREGOING LIMITATIONS AND EXCLUSIONS IN THIS SECTION ‎7 SHALL APPLY: (I) EVEN IF APPLITOOLS HAS BEEN ADVISED OF THE POSSIBILITY OF ANY DAMAGES OR LOSSES; (II) EVEN IF ANY REMEDY SET FORTH HEREIN FAILS OF ITS ESSENTIAL PURPOSE; AND (III) REGARDLESS OF THE BASIS OR THEORY OF LIABILITY.
+1. Export Laws. Licensee agrees to comply fully with all U.S., EU, Israeli, and all applicable export laws and regulations to ensure that neither the Software nor any technical data related thereto are exported or re-exported directly or indirectly in violation of, or used for any purposes prohibited by, such laws and regulations. For clarity, and without derogating from Section ‎11 below, in case of any change of any applicable law, policy or regulation, which might affect Applitools’ business, Applitools will have the right to terminate this Agreement and the license granted hereunder and the Licensee shall have no claims regarding such termination. 
+1. Term and Termination. This Agreement shall continue until terminated as set forth in this section (the “Term”). You may terminate this Agreement at any time by removing the Software from Your system and destroying all copies of the Software and Documentation relating to the Software. Unauthorized copying of the Software or otherwise failing to comply with this Agreement will result in automatic immediate termination of this Agreement and will make available to Applitools legal remedies. Applitools reserves the right to terminate this Agreement and the License at any time and without notice. Upon termination of this Agreement, the License will terminate and You: (i) will cease any and all rights to use the Software, and (ii) will remove the Software from all hard drives, networks and other storage media and destroy all copies of the Software in your possession or under your control. The provisions of Sections ‎2.3, ‎2.4, ‎2.5, ‎6, ‎7, ‎8, ‎9, 10, ‎11 and ‎12 shall survive the termination, expiration or other ending of this Agreement.
+1. Miscellaneous. This Agreement represents the complete agreement concerning the Software between You and Applitools and supersedes all prior agreements and representations between You and Applitools. If any provision of this Agreement is held to be unenforceable for any reason, such provision shall be reformed only to the extent necessary to make it enforceable. Any waiver of any provision of this Agreement will be effective only if in writing and signed by Applitools. This Agreement is personal to You and may not be assigned or transferred for any reason whatsoever without the consent of Applitools and any action or conduct in violation of the foregoing shall be void and without effect. Applitools expressly reserves the right to assign this Agreement and to delegate any of its obligations hereunder. This Agreement are governed by and construed under the laws of the State of Israel, excluding its conflicts of law rules. You expressly agree that the exclusive jurisdiction for any claim or action arising out of or relating to this Agreement shall be the courts located in Tel Aviv, Israel, and You further agree and submit to the exercise of personal jurisdiction of such courts for the purpose of litigating any such claim or action. In any action or proceeding to enforce rights under this Agreement, the prevailing party shall be entitled to recover costs and attorneys’ fees.

package/dist/formats/bmp.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBmpBuffer = exports.extractBmpSize = exports.isBmpBuffer = void 0;
+const bmp = __importStar(require("bmpimagejs"));
+function isBmpBuffer(buffer) {
+    return new TextDecoder().decode(buffer.subarray(0, 2)) === 'BM';
+}
+exports.isBmpBuffer = isBmpBuffer;
+function extractBmpSize(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return { width: view.getUint32(18, true), height: view.getUint32(22, true) };
+}
+exports.extractBmpSize = extractBmpSize;
+async function fromBmpBuffer(buffer) {
+    const image = bmp.decode(buffer);
+    return {
+        data: new Uint8Array(image.pixels.buffer, image.pixels.byteOffset, image.pixels.byteLength),
+        width: image.width,
+        height: image.height,
+    };
+}
+exports.fromBmpBuffer = fromBmpBuffer;

package/dist/formats/gif.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.freezeGif = exports.fromGifBuffer = exports.extractGifSize = exports.isGifBuffer = void 0;
+const gif = __importStar(require("omggif"));
+function isGifBuffer(buffer) {
+    return ['GIF87a', 'GIF89a'].includes(new TextDecoder().decode(buffer.subarray(0, 6)));
+}
+exports.isGifBuffer = isGifBuffer;
+function extractGifSize(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+}
+exports.extractGifSize = extractGifSize;
+async function fromGifBuffer(buffer) {
+    const reader = new gif.GifReader(buffer);
+    const data = new Uint8Array(reader.width * reader.height * 4).fill(0);
+    reader.decodeAndBlitFrameRGBA(0, data);
+    return { width: reader.width, height: reader.height, data };
+}
+exports.fromGifBuffer = fromGifBuffer;
+async function freezeGif(buffer) {
+    const reader = new gif.GifReader(buffer);
+    if (reader.numFrames() === 0)
+        return buffer;
+    const frame = reader.frameInfo(0);
+    return buffer.subarray(0, frame.data_offset + frame.data_length);
+}
+exports.freezeGif = freezeGif;

package/dist/formats/jpeg.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJpegBuffer = exports.extractJpegSize = exports.isJpegBuffer = void 0;
+const jpeg = __importStar(require("jpeg-js"));
+function isJpegBuffer(buffer) {
+    return ['JFIF', 'Exif'].includes(new TextDecoder().decode(buffer.subarray(6, 10)));
+}
+exports.isJpegBuffer = isJpegBuffer;
+function extractJpegSize(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    // skip file signature
+    let offset = 4;
+    while (view.byteLength > offset) {
+        // extract length of the block
+        offset += view.getUint16(offset);
+        // if next segment is SOF0 or SOF2 extract size
+        if (view.getUint8(offset + 1) === 0xc0 || view.getUint8(offset + 1) === 0xc2) {
+            return { width: view.getUint16(offset + 7), height: view.getUint16(offset + 5) };
+        }
+        else {
+            // skip block signature
+            offset += 2;
+        }
+    }
+    return { width: 0, height: 0 };
+}
+exports.extractJpegSize = extractJpegSize;
+async function fromJpegBuffer(buffer) {
+    return jpeg.decode(buffer, { tolerantDecoding: true, formatAsRGBA: true });
+}
+exports.fromJpegBuffer = fromJpegBuffer;

package/dist/formats/png-sharp.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPngSharp = exports.fromPngBufferSharp = void 0;
+const sharp_1 = __importDefault(require("sharp"));
+const buffer_1 = require("buffer");
+async function fromPngBufferSharp(buffer) {
+    // Ensure we always get RGBA (4 channels) output for consistency
+    const { data, info } = await (0, sharp_1.default)(buffer_1.Buffer.from(buffer))
+        .ensureAlpha() // Force RGBA output
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return {
+        width: info.width,
+        height: info.height,
+        data: data,
+    };
+}
+exports.fromPngBufferSharp = fromPngBufferSharp;
+async function toPngSharp(image) {
+    // Calculate channels from data size (only support RGB=3 and RGBA=4)
+    const calculatedChannels = image.data.length / (image.width * image.height);
+    const channels = Math.round(calculatedChannels);
+    // Validate channels and data size
+    if (![3, 4].includes(channels) || Math.abs(channels - calculatedChannels) > 0.01) {
+        throw new Error(`Invalid image data: expected ${image.width}x${image.height} with RGB (3) or RGBA (4) channels, ` +
+            `got ${image.data.length} bytes (${calculatedChannels.toFixed(2)} channels)`);
+    }
+    return await (0, sharp_1.default)(buffer_1.Buffer.from(image.data), {
+        raw: {
+            width: image.width,
+            height: image.height,
+            channels,
+        },
+    })
+        .png({
+        compressionLevel: 9,
+        adaptiveFiltering: false,
+    })
+        .toBuffer();
+}
+exports.toPngSharp = toPngSharp;

package/dist/formats/png.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateWhitePng = exports.toPng = exports.fromPngBuffer = exports.extractPngSize = exports.isPngBuffer = void 0;
+const buffer_1 = require("buffer");
+const png = __importStar(require("png-async"));
+const utils = __importStar(require("@applitools/utils"));
+function isPngBuffer(buffer) {
+    return new TextDecoder().decode(buffer.subarray(12, 16)) === 'IHDR';
+}
+exports.isPngBuffer = isPngBuffer;
+function extractPngSize(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+exports.extractPngSize = extractPngSize;
+/**
+ * Dynamically import png-sharp module
+ * Tries .js first (production), then .ts (ts-node/dev)
+ */
+async function importPngSharp() {
+    try {
+        return await import('./png-sharp.js');
+    }
+    catch (error) {
+        // In ts-node, .js imports fail, try .ts instead
+        // Use dynamic string to bypass TypeScript's static import checking
+        const tsPath = './png-sharp' + '.ts';
+        return await import(tsPath);
+    }
+}
+/**
+ * Decode PNG buffer to ImageRaw
+ * Tries sharp first (faster), falls back to png-async if sharp fails
+ */
+async function fromPngBuffer(buffer, defaultLogger) {
+    const logger = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'image/png' });
+    try {
+        const pngSharp = await importPngSharp();
+        const result = await pngSharp.fromPngBufferSharp(buffer);
+        logger === null || logger === void 0 ? void 0 : logger.log('Used Sharp for PNG decoding');
+        return result;
+    }
+    catch (error) {
+        // Fallback to png-async if sharp fails (SEA, not installed, or runtime error)
+        logger === null || logger === void 0 ? void 0 : logger.log('Falling back to png-async for PNG decoding:', error instanceof Error ? error.message : String(error));
+        return new Promise((resolve, reject) => {
+            const image = new png.Image();
+            image.parse(buffer_1.Buffer.from(buffer), (err, image) => {
+                if (err)
+                    return reject(err);
+                resolve(image);
+            });
+        });
+    }
+}
+exports.fromPngBuffer = fromPngBuffer;
+/**
+ * Encode ImageRaw to PNG buffer
+ * Tries sharp first (22× faster), falls back to png-async if sharp fails
+ */
+async function toPng(image, defaultLogger) {
+    const logger = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'image/png' });
+    try {
+        const pngSharp = await importPngSharp();
+        const result = await pngSharp.toPngSharp(image);
+        logger === null || logger === void 0 ? void 0 : logger.log('Used Sharp for PNG encoding');
+        return result;
+    }
+    catch (error) {
+        // Fallback to png-async if sharp fails (SEA, not installed, or runtime error)
+        // Uses RLE strategy (default) for optimal performance (~35ms)
+        logger === null || logger === void 0 ? void 0 : logger.log('Falling back to png-async for PNG encoding:', error instanceof Error ? error.message : String(error));
+        const expectedSize = image.width * image.height * 4;
+        const actualSize = image.data.length;
+        if (actualSize !== expectedSize) {
+            throw new Error(`Image data size mismatch: expected ${expectedSize} bytes for ${image.width}x${image.height}, got ${actualSize} bytes`);
+        }
+        const wrapper = new png.Image({ width: image.width, height: image.height });
+        wrapper.data = buffer_1.Buffer.from(image.data);
+        return utils.streams.toBuffer(wrapper.pack());
+    }
+}
+exports.toPng = toPng;
+// A blank placeholder image sized to a viewport (e.g. a design-comparison step that has only a size, not a design).
+async function generateWhitePng(width, height) {
+    const image = new png.Image({ width, height });
+    image.data = buffer_1.Buffer.alloc(width * height * 4, 0xff); // opaque white RGBA
+    return utils.streams.toBuffer(image.pack());
+}
+exports.generateWhitePng = generateWhitePng;

package/dist/image.js

@@ -0,0 +1,593 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeImage = void 0;
+const png_1 = require("./formats/png");
+const jpeg_1 = require("./formats/jpeg");
+const bmp_1 = require("./formats/bmp");
+const gif_1 = require("./formats/gif");
+const buffer_1 = require("buffer");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils = __importStar(require("@applitools/utils"));
+function makeImage(data, defaultLogger) {
+    let image, size;
+    let transforms = { rotate: 0, scale: 1, crop: undefined, modifiers: [] };
+    const logger = defaultLogger === null || defaultLogger === void 0 ? void 0 : defaultLogger.extend({ label: 'image' });
+    if (utils.types.isUint8Array(data) || utils.types.isAnyArrayBuffer(data)) {
+        const buffer = utils.types.isAnyArrayBuffer(data) ? new Uint8Array(data) : data;
+        if ((0, png_1.isPngBuffer)(buffer)) {
+            image = (0, png_1.fromPngBuffer)(buffer, logger);
+            size = (0, png_1.extractPngSize)(buffer);
+        }
+        else if ((0, jpeg_1.isJpegBuffer)(buffer)) {
+            image = (0, jpeg_1.fromJpegBuffer)(buffer);
+            size = (0, jpeg_1.extractJpegSize)(buffer);
+        }
+        else if ((0, bmp_1.isBmpBuffer)(buffer)) {
+            image = (0, bmp_1.fromBmpBuffer)(buffer);
+            size = (0, bmp_1.extractBmpSize)(buffer);
+        }
+        else if ((0, gif_1.isGifBuffer)(buffer)) {
+            image = (0, gif_1.fromGifBuffer)(buffer);
+            size = (0, gif_1.extractGifSize)(buffer);
+        }
+        else {
+            throw new Error('Unable to create an image abstraction from buffer with unknown data');
+        }
+    }
+    else if (utils.types.isBase64(data)) {
+        return makeImage(buffer_1.Buffer.from(data, 'base64'));
+    }
+    else if (utils.types.isString(data)) {
+        return makeImage(fs_1.default.readFileSync(data));
+    }
+    else if (utils.types.has(data, 'isImage')) {
+        transforms = data.transforms;
+        image = data.toRaw();
+        size = data.rawSize;
+    }
+    else if (utils.types.has(data, ['width', 'height'])) {
+        image = fromSize(data);
+        if (utils.types.has(data, 'data') && data.data)
+            image.data = data.data;
+        size = { width: data.width, height: data.height };
+    }
+    else if (data.auto) {
+        size = { width: -1, height: -1 };
+    }
+    else {
+        throw new Error('Unable to create an image abstraction from unknown data');
+    }
+    return {
+        get isImage() {
+            return true;
+        },
+        get size() {
+            var _a;
+            const croppedSize = utils.geometry.size((_a = transforms.crop) !== null && _a !== void 0 ? _a : size);
+            const scaledSize = utils.geometry.scale(croppedSize, transforms.scale);
+            const rotatedSize = utils.geometry.rotate(scaledSize, transforms.rotate);
+            return utils.geometry.ceil(rotatedSize);
+        },
+        get unscaledSize() {
+            var _a;
+            const croppedSize = utils.geometry.size((_a = transforms.crop) !== null && _a !== void 0 ? _a : size);
+            const rotatedSize = utils.geometry.rotate(croppedSize, transforms.rotate);
+            return utils.geometry.ceil(rotatedSize);
+        },
+        get rawSize() {
+            return size;
+        },
+        get transforms() {
+            return { ...transforms };
+        },
+        get width() {
+            return this.size.width;
+        },
+        get height() {
+            return this.size.height;
+        },
+        scale(ratio) {
+            transforms.scale *= ratio;
+            return this;
+        },
+        rotate(degrees) {
+            transforms.rotate = (transforms.rotate + degrees) % 360;
+            return this;
+        },
+        crop(region) {
+            if (utils.types.has(region, ['left', 'right', 'top', 'bottom'])) {
+                region = {
+                    x: region.left / transforms.scale,
+                    y: region.top / transforms.scale,
+                    width: size.width - (region.left + region.right) / transforms.scale,
+                    height: size.height - (region.top + region.bottom) / transforms.scale,
+                };
+            }
+            else {
+                region = utils.geometry.scale(region, 1 / transforms.scale);
+            }
+            region = utils.geometry.rotate(region, -transforms.rotate, utils.geometry.rotate(size, transforms.rotate));
+            region = transforms.crop
+                ? utils.geometry.intersect(transforms.crop, utils.geometry.offset(region, transforms.crop))
+                : utils.geometry.intersect({ x: 0, y: 0, ...size }, region);
+            transforms.crop = region;
+            size = utils.geometry.size(region);
+            return this;
+        },
+        copy(srcImage, offset) {
+            // if "auto" image and this is first chunk
+            if (!image && size.width === -1 && size.height === -1)
+                transforms.scale = srcImage.transforms.scale;
+            const unscaledOffset = utils.geometry.scale(offset, 1 / transforms.scale);
+            if (!image) {
+                size = {
+                    width: Math.max(Math.floor(unscaledOffset.x) + srcImage.unscaledSize.width, size.width),
+                    height: Math.max(Math.floor(unscaledOffset.y) + srcImage.unscaledSize.height, size.height),
+                };
+            }
+            const unscale = srcImage.transforms.scale === transforms.scale
+                ? 1 / srcImage.transforms.scale
+                : srcImage.transforms.scale / transforms.scale;
+            transforms.modifiers.push({ type: 'copy', image: srcImage.scale(unscale).toObject(), offset: unscaledOffset });
+            return this;
+        },
+        frame(topImage, bottomImage, region) {
+            const prevSize = size;
+            const unscaledRegion = utils.geometry.scale(region, 1 / topImage.transforms.scale);
+            size = {
+                width: Math.floor(topImage.unscaledSize.width + Math.max(size.width - unscaledRegion.width, 0)),
+                height: Math.floor(topImage.unscaledSize.height + Math.max(size.height - unscaledRegion.height, 0)),
+            };
+            const unscale = topImage.transforms.scale === transforms.scale
+                ? 1 / topImage.transforms.scale
+                : topImage.transforms.scale / transforms.scale;
+            transforms.modifiers.push({
+                type: 'frame',
+                top: topImage.scale(unscale).toObject(),
+                bottom: bottomImage.scale(unscale).toObject(),
+                region: unscaledRegion,
+            });
+            transforms.added = { width: size.width - prevSize.width, height: size.height - prevSize.height };
+            return this;
+        },
+        async toRaw() {
+            return image;
+        },
+        async toBuffer() {
+            const image = await this.toObject();
+            return image.data;
+        },
+        async toPng() {
+            return (0, png_1.toPng)(await this.toObject(), logger);
+        },
+        async toFile(path) {
+            return toFile(await image, path, logger);
+        },
+        async toObject() {
+            image = await transform(image ? await image : size, transforms);
+            size = { width: image.width, height: image.height };
+            transforms = { crop: undefined, scale: 1, rotate: 0, modifiers: [] };
+            return image;
+        },
+        async debug(debug) {
+            if (!debug || !debug.path)
+                return;
+            const timestamp = new Date().toISOString().replace(/[-T:.]/g, '_');
+            const filename = ['screenshot', timestamp, debug.name, debug.suffix].filter(part => part).join('_') + '.png';
+            const transformedImage = await transform(image ? await image : size, transforms);
+            return toFile(transformedImage, path_1.default.join(debug.path, filename), logger).catch(() => undefined);
+        },
+    };
+}
+exports.makeImage = makeImage;
+function fromSize(size) {
+    return { ...size, data: new Uint8Array(4 * size.width * size.height) };
+}
+async function toFile(image, filepath, logger) {
+    const buffer = await (0, png_1.toPng)(image, logger);
+    return new Promise((resolve, reject) => {
+        fs_1.default.mkdirSync(path_1.default.dirname(filepath), { recursive: true });
+        fs_1.default.writeFile(filepath, buffer, err => (err ? reject(err) : resolve()));
+    });
+}
+async function transform(imageOrSize, transforms) {
+    let image;
+    if (utils.types.has(imageOrSize, 'data')) {
+        image = imageOrSize;
+    }
+    else {
+        const size = transforms.added
+            ? { width: imageOrSize.width - transforms.added.width, height: imageOrSize.height - transforms.added.height }
+            : imageOrSize;
+        image = fromSize(size);
+    }
+    image = await transforms.modifiers.reduce(async (image, modifier) => {
+        if (modifier.type === 'copy') {
+            return copy(await image, await modifier.image, modifier.offset);
+        }
+        else if (modifier.type === 'frame') {
+            return frame(await modifier.top, await modifier.bottom, await image, modifier.region);
+        }
+        else {
+            return image;
+        }
+    }, Promise.resolve(image));
+    image = transforms.crop ? await extract(image, transforms.crop) : image;
+    image = transforms.scale !== 1 ? await scale(image, transforms.scale) : image;
+    image = transforms.rotate !== 0 ? await rotate(image, transforms.rotate) : image;
+    return image;
+}
+async function scale(image, scaleRatio) {
+    if (scaleRatio === 1)
+        return image;
+    const ratio = image.height / image.width;
+    const scaledWidth = Math.ceil(image.width * scaleRatio);
+    const scaledHeight = Math.ceil(scaledWidth * ratio);
+    return resize(image, { width: scaledWidth, height: scaledHeight });
+}
+async function resize(image, size) {
+    const dst = fromSize(size);
+    if (dst.width > image.width || dst.height > image.height) {
+        _doBicubicInterpolation(image, dst);
+    }
+    else {
+        _scaleImageIncrementally(image, dst);
+    }
+    image.data = dst.data;
+    image.width = dst.width;
+    image.height = dst.height;
+    return image;
+}
+async function extract(image, region) {
+    const srcX = Math.max(0, Math.round(region.x));
+    const srcY = Math.max(0, Math.round(region.y));
+    const dstWidth = Math.round(Math.min(image.width - srcX, region.width));
+    const dstHeight = Math.round(Math.min(image.height - srcY, region.height));
+    const dstSize = { width: dstWidth, height: dstHeight };
+    if (utils.geometry.isEmpty(dstSize)) {
+        throw new Error(`Cannot extract empty region (${srcX};${srcY})${dstWidth}x${dstHeight} from image`);
+    }
+    const extracted = fromSize(dstSize);
+    if (srcX === 0 && dstWidth === image.width) {
+        const srcOffset = srcY * image.width * 4;
+        const dstLength = dstWidth * dstHeight * 4;
+        extracted.data.set(image.data.subarray(srcOffset, srcOffset + dstLength));
+    }
+    else {
+        const chunkLength = dstWidth * 4;
+        for (let chunk = 0; chunk < dstHeight; ++chunk) {
+            const srcOffset = ((srcY + chunk) * image.width + srcX) * 4;
+            extracted.data.set(image.data.subarray(srcOffset, srcOffset + chunkLength), chunk * chunkLength);
+        }
+    }
+    return extracted;
+}
+async function rotate(image, degrees) {
+    degrees = (360 + degrees) % 360;
+    const dstImage = fromSize({ width: image.width, height: image.height });
+    const srcView = new DataView(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+    const dstView = new DataView(dstImage.data.buffer, dstImage.data.byteOffset, dstImage.data.byteLength);
+    if (degrees === 90) {
+        dstImage.width = image.height;
+        dstImage.height = image.width;
+        for (let srcY = 0, dstX = image.height - 1; srcY < image.height; ++srcY, --dstX) {
+            for (let srcX = 0, dstY = 0; srcX < image.width; ++srcX, ++dstY) {
+                const pixel = srcView.getUint32((srcY * image.width + srcX) * 4);
+                dstView.setUint32((dstY * dstImage.width + dstX) * 4, pixel);
+            }
+        }
+    }
+    else if (degrees === 180) {
+        dstImage.width = image.width;
+        dstImage.height = image.height;
+        for (let srcY = 0, dstY = image.height - 1; srcY < image.height; ++srcY, --dstY) {
+            for (let srcX = 0, dstX = image.width - 1; srcX < image.width; ++srcX, --dstX) {
+                const pixel = srcView.getUint32((srcY * image.width + srcX) * 4);
+                dstView.setUint32((dstY * dstImage.width + dstX) * 4, pixel);
+            }
+        }
+    }
+    else if (degrees === 270) {
+        dstImage.width = image.height;
+        dstImage.height = image.width;
+        for (let srcY = 0, dstX = 0; srcY < image.height; ++srcY, ++dstX) {
+            for (let srcX = 0, dstY = image.width - 1; srcX < image.width; ++srcX, --dstY) {
+                const pixel = srcView.getUint32((srcY * image.width + srcX) * 4);
+                dstView.setUint32((dstY * dstImage.width + dstX) * 4, pixel);
+            }
+        }
+    }
+    else {
+        dstImage.data.set(image.data);
+    }
+    return dstImage;
+}
+async function copy(dstImage, srcImage, offset) {
+    const dstX = Math.round(offset.x);
+    const dstY = Math.round(offset.y);
+    const srcWidth = Math.min(srcImage.width, dstImage.width - dstX);
+    const srcHeight = Math.min(srcImage.height, dstImage.height - dstY);
+    if (dstX === 0 && srcWidth === dstImage.width && srcWidth === srcImage.width) {
+        const dstOffset = dstY * dstImage.width * 4;
+        dstImage.data.set(srcImage.data.subarray(0, srcWidth * srcHeight * 4), dstOffset);
+        return dstImage;
+    }
+    const chunkLength = srcWidth * 4;
+    for (let chunk = 0; chunk < srcHeight; ++chunk) {
+        const srcOffset = chunk * srcImage.width * 4;
+        const dstOffset = ((dstY + chunk) * dstImage.width + dstX) * 4;
+        if (dstOffset >= 0) {
+            dstImage.data.set(srcImage.data.subarray(srcOffset, srcOffset + chunkLength), dstOffset);
+        }
+    }
+    return dstImage;
+}
+async function frame(topImage, bottomImage, srcImage, region) {
+    region = utils.geometry.intersect({ x: 0, y: 0, width: topImage.width, height: topImage.height }, utils.geometry.round(region));
+    if (region.x === 0 && region.y === 0 && region.width >= topImage.width && region.height >= topImage.height) {
+        return srcImage;
+    }
+    if (region.width >= srcImage.width && region.height >= srcImage.height) {
+        await copy(topImage, srcImage, { x: region.x, y: region.y });
+        return topImage;
+    }
+    const dstImage = fromSize({
+        width: topImage.width + Math.max(srcImage.width - region.width, 0),
+        height: topImage.height + Math.max(srcImage.height - region.height, 0),
+    });
+    if (region.width === srcImage.width) {
+        const topExtImage = await extract(topImage, {
+            x: 0,
+            y: 0,
+            width: topImage.width,
+            height: region.y + region.height,
+        });
+        await copy(dstImage, topExtImage, { x: 0, y: 0 });
+    }
+    else if (region.height === srcImage.height) {
+        const leftExtImage = await extract(topImage, {
+            x: 0,
+            y: 0,
+            width: region.x + region.width,
+            height: topImage.height,
+        });
+        await copy(dstImage, leftExtImage, { x: 0, y: 0 });
+    }
+    else {
+        const topLeftExtImage = await extract(topImage, {
+            x: 0,
+            y: 0,
+            width: region.x + region.width,
+            height: region.y + region.height,
+        });
+        await copy(dstImage, topLeftExtImage, { x: 0, y: 0 });
+        const rightExtImage = await extract(topImage, {
+            x: region.x + region.width,
+            y: 0,
+            width: topImage.width - (region.x + region.width),
+            height: region.y,
+        });
+        await copy(dstImage, rightExtImage, { x: region.x + region.width, y: 0 });
+        const bottomExtImage = await extract(topImage, {
+            x: 0,
+            y: region.y + region.height,
+            width: region.x,
+            height: topImage.height - (region.y + region.height),
+        });
+        await copy(dstImage, bottomExtImage, { x: 0, y: region.y + region.height });
+    }
+    if (bottomImage.height > region.y + region.height || bottomImage.width > region.x + region.width) {
+        // first image might be higher
+        const yDiff = topImage.height - bottomImage.height;
+        if (region.width === srcImage.width) {
+            const bottomExtImage = await extract(bottomImage, {
+                x: 0,
+                y: region.y - yDiff + region.height,
+                width: bottomImage.width,
+                height: bottomImage.height - (region.y - yDiff + region.height),
+            });
+            await copy(dstImage, bottomExtImage, { x: 0, y: region.y + Math.max(srcImage.height, region.height) });
+        }
+        else if (region.height === srcImage.height) {
+            const rightExtImage = await extract(bottomImage, {
+                x: region.x + region.width,
+                y: 0,
+                width: bottomImage.width - (region.x + region.width),
+                height: bottomImage.height,
+            });
+            await copy(dstImage, rightExtImage, { x: region.x + Math.max(srcImage.width, region.width), y: 0 });
+        }
+        else {
+            const bottomRightExtImage = await extract(bottomImage, {
+                x: region.x,
+                y: region.y - yDiff,
+                width: bottomImage.width - region.x,
+                height: bottomImage.height - (region.y - yDiff),
+            });
+            await copy(dstImage, bottomRightExtImage, {
+                x: region.x + Math.max(srcImage.width - region.width, 0),
+                y: region.y + Math.max(srcImage.height - region.height, 0),
+            });
+        }
+    }
+    await copy(dstImage, srcImage, { x: region.x, y: region.y });
+    return dstImage;
+}
+function _interpolateCubic(x0, x1, x2, x3, t) {
+    const a0 = x3 - x2 - x0 + x1;
+    const a1 = x0 - x1 - a0;
+    const a2 = x2 - x0;
+    return Math.ceil(Math.max(0, Math.min(255, a0 * (t * t * t) + a1 * (t * t) + (a2 * t + x1))));
+}
+function _interpolateRows(bufSrc, wSrc, hSrc, wDst) {
+    const buf = new Uint8Array(wDst * hSrc * 4);
+    for (let i = 0; i < hSrc; i += 1) {
+        for (let j = 0; j < wDst; j += 1) {
+            const x = (j * (wSrc - 1)) / wDst;
+            const xPos = Math.floor(x);
+            const t = x - xPos;
+            const srcPos = (i * wSrc + xPos) * 4;
+            const buf1Pos = (i * wDst + j) * 4;
+            for (let k = 0; k < 4; k += 1) {
+                const kPos = srcPos + k;
+                const x0 = xPos > 0 ? bufSrc[kPos - 4] : 2 * bufSrc[kPos] - bufSrc[kPos + 4];
+                const x1 = bufSrc[kPos];
+                const x2 = bufSrc[kPos + 4];
+                const x3 = xPos < wSrc - 2 ? bufSrc[kPos + 8] : 2 * bufSrc[kPos + 4] - bufSrc[kPos];
+                buf[buf1Pos + k] = _interpolateCubic(x0, x1, x2, x3, t);
+            }
+        }
+    }
+    return buf;
+}
+function _interpolateColumns(bufSrc, hSrc, wDst, hDst) {
+    const buf = new Uint8Array(wDst * hDst * 4);
+    for (let i = 0; i < hDst; i += 1) {
+        for (let j = 0; j < wDst; j += 1) {
+            const y = (i * (hSrc - 1)) / hDst;
+            const yPos = Math.floor(y);
+            const t = y - yPos;
+            const buf1Pos = (yPos * wDst + j) * 4;
+            const buf2Pos = (i * wDst + j) * 4;
+            for (let k = 0; k < 4; k += 1) {
+                const kPos = buf1Pos + k;
+                const y0 = yPos > 0 ? bufSrc[kPos - wDst * 4] : 2 * bufSrc[kPos] - bufSrc[kPos + wDst * 4];
+                const y1 = bufSrc[kPos];
+                const y2 = bufSrc[kPos + wDst * 4];
+                const y3 = yPos < hSrc - 2 ? bufSrc[kPos + wDst * 8] : 2 * bufSrc[kPos + wDst * 4] - bufSrc[kPos];
+                buf[buf2Pos + k] = _interpolateCubic(y0, y1, y2, y3, t);
+            }
+        }
+    }
+    return buf;
+}
+function _interpolateScale(bufColumns, wDst, hDst, wDst2, m, wM, hM) {
+    const buf = new Uint8Array(wDst * hDst * 4);
+    for (let i = 0; i < hDst; i += 1) {
+        for (let j = 0; j < wDst; j += 1) {
+            let r = 0;
+            let g = 0;
+            let b = 0;
+            let a = 0;
+            let realColors = 0;
+            for (let y = 0; y < hM; y += 1) {
+                const yPos = i * hM + y;
+                for (let x = 0; x < wM; x += 1) {
+                    const xPos = j * wM + x;
+                    const xyPos = (yPos * wDst2 + xPos) * 4;
+                    const pixelAlpha = bufColumns[xyPos + 3];
+                    if (pixelAlpha) {
+                        r += bufColumns[xyPos];
+                        g += bufColumns[xyPos + 1];
+                        b += bufColumns[xyPos + 2];
+                        realColors += 1;
+                    }
+                    a += pixelAlpha;
+                }
+            }
+            const pos = (i * wDst + j) * 4;
+            buf[pos] = realColors ? Math.round(r / realColors) : 0;
+            buf[pos + 1] = realColors ? Math.round(g / realColors) : 0;
+            buf[pos + 2] = realColors ? Math.round(b / realColors) : 0;
+            buf[pos + 3] = Math.round(a / m);
+        }
+    }
+    return buf;
+}
+function _doBicubicInterpolation(src, dst) {
+    // The implementation was taken from
+    // https://github.com/oliver-moran/jimp/blob/master/resize2.js
+    // when dst smaller than src/2, interpolate first to a multiple between 0.5 and 1.0 src, then sum squares
+    const wM = Math.max(1, Math.floor(src.width / dst.width));
+    const wDst2 = dst.width * wM;
+    const hM = Math.max(1, Math.floor(src.height / dst.height));
+    const hDst2 = dst.height * hM;
+    // Pass 1 - interpolate rows
+    // bufRows has width of dst2 and height of src
+    const bufRows = _interpolateRows(src.data, src.width, src.height, wDst2);
+    // Pass 2 - interpolate columns
+    // bufColumns has width and height of dst2
+    const bufColumns = _interpolateColumns(bufRows, src.height, wDst2, hDst2);
+    // Pass 3 - scale to dst
+    const m = wM * hM;
+    if (m > 1) {
+        dst.data = _interpolateScale(bufColumns, dst.width, dst.height, wDst2, m, wM, hM);
+    }
+    else {
+        dst.data = bufColumns;
+    }
+    return dst;
+}
+function _scaleImageIncrementally(src, dst) {
+    let currentWidth = src.width;
+    let currentHeight = src.height;
+    const targetWidth = dst.width;
+    const targetHeight = dst.height;
+    dst.data = src.data;
+    dst.width = src.width;
+    dst.height = src.height;
+    // For ultra quality should use 7
+    const fraction = 2;
+    do {
+        const prevCurrentWidth = currentWidth;
+        const prevCurrentHeight = currentHeight;
+        // If the current width is bigger than our target, cut it in half and sample again.
+        if (currentWidth > targetWidth) {
+            currentWidth -= Math.floor(currentWidth / fraction);
+            // If we cut the width too far it means we are on our last iteration. Just set it to the target width
+            // and finish up.
+            if (currentWidth < targetWidth) {
+                currentWidth = targetWidth;
+            }
+        }
+        // If the current height is bigger than our target, cut it in half and sample again.
+        if (currentHeight > targetHeight) {
+            currentHeight -= Math.floor(currentHeight / fraction);
+            // If we cut the height too far it means we are on our last iteration. Just set it to the target height
+            // and finish up.
+            if (currentHeight < targetHeight) {
+                currentHeight = targetHeight;
+            }
+        }
+        // Stop when we cannot incrementally step down anymore.
+        if (prevCurrentWidth === currentWidth && prevCurrentHeight === currentHeight) {
+            return dst;
+        }
+        // Render the incremental scaled image.
+        const incrementalImage = fromSize({ width: currentWidth, height: currentHeight });
+        _doBicubicInterpolation(dst, incrementalImage);
+        // Now treat our incremental partially scaled image as the src image
+        // and cycle through our loop again to do another incremental scaling of it (if necessary).
+        dst.data = incrementalImage.data;
+        dst.width = incrementalImage.width;
+        dst.height = incrementalImage.height;
+    } while (currentWidth !== targetWidth || currentHeight !== targetHeight);
+    return dst;
+}

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./image"), exports);
+__exportStar(require("./formats/png"), exports);
+__exportStar(require("./formats/jpeg"), exports);
+__exportStar(require("./formats/bmp"), exports);
+__exportStar(require("./formats/gif"), exports);

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@ohos-ports/applitools-image",
+  "version": "1.3.2-beta.1",
+  "description": "Image primitive used for capturing and manipulating screenshots",
+  "homepage": "https://applitools.com",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/applitools-image/1.3.2"
+  },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": {
+    "name": "Applitools Team",
+    "email": "team@applitools.com"
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "main": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "lint": "run --top-level eslint '**/*.ts'",
+    "build": "run --top-level tsc --project ./tsconfig.build.json",
+    "test": "run --top-level mocha './test/**/*.spec.ts'"
+  },
+  "dependencies": {
+    "@applitools/logger": "2.3.1",
+    "@applitools/utils": "1.15.2",
+    "bmpimagejs": "1.0.4",
+    "jpeg-js": "0.4.4",
+    "omggif": "1.0.10",
+    "png-async": "0.9.4",
+    "@ohos-ports/sharp": "^0.34.5-beta.11"
+  },
+  "devDependencies": {
+    "@applitools/test-utils": "^1.5.17",
+    "@types/node": "^12.20.55",
+    "@types/omggif": "^1.0.3",
+    "@types/pixelmatch": "^5.2.4",
+    "pixelmatch": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=12.13.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "lavamoat": {
+    "allowScripts": {
+      "sharp": true
+    }
+  }
+}

package/types/formats/bmp.d.ts

@@ -0,0 +1,5 @@
+import type { ImageBuffer, ImageRaw } from '../types';
+import type { Size } from '@applitools/utils';
+export declare function isBmpBuffer(buffer: ImageBuffer): boolean;
+export declare function extractBmpSize(buffer: ImageBuffer): Size;
+export declare function fromBmpBuffer(buffer: ImageBuffer): Promise<ImageRaw>;

package/types/formats/gif.d.ts

@@ -0,0 +1,6 @@
+import type { ImageBuffer, ImageRaw } from '../types';
+import type { Size } from '@applitools/utils';
+export declare function isGifBuffer(buffer: ImageBuffer): boolean;
+export declare function extractGifSize(buffer: ImageBuffer): Size;
+export declare function fromGifBuffer(buffer: ImageBuffer): Promise<ImageRaw>;
+export declare function freezeGif(buffer: ImageBuffer): Promise<ImageBuffer>;

package/types/formats/jpeg.d.ts

@@ -0,0 +1,5 @@
+import type { ImageBuffer, ImageRaw } from '../types';
+import type { Size } from '@applitools/utils';
+export declare function isJpegBuffer(buffer: ImageBuffer): boolean;
+export declare function extractJpegSize(buffer: ImageBuffer): Size;
+export declare function fromJpegBuffer(buffer: ImageBuffer): Promise<ImageRaw>;

package/types/formats/png-sharp.d.ts

@@ -0,0 +1,3 @@
+import type { ImageBuffer, ImageRaw } from '../types';
+export declare function fromPngBufferSharp(buffer: ImageBuffer): Promise<ImageRaw>;
+export declare function toPngSharp(image: ImageRaw): Promise<ImageBuffer>;

package/types/formats/png.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { ImageBuffer, ImageRaw } from '../types';
+import type { Size } from '@applitools/utils';
+import type { Logger } from '@applitools/logger';
+export declare function isPngBuffer(buffer: ImageBuffer): boolean;
+export declare function extractPngSize(buffer: ImageBuffer): Size;
+/**
+ * Decode PNG buffer to ImageRaw
+ * Tries sharp first (faster), falls back to png-async if sharp fails
+ */
+export declare function fromPngBuffer(buffer: ImageBuffer, defaultLogger?: Logger): Promise<ImageRaw>;
+/**
+ * Encode ImageRaw to PNG buffer
+ * Tries sharp first (22× faster), falls back to png-async if sharp fails
+ */
+export declare function toPng(image: ImageRaw, defaultLogger?: Logger): Promise<ImageBuffer>;
+export declare function generateWhitePng(width: number, height: number): Promise<Buffer>;

package/types/image.d.ts

@@ -0,0 +1,46 @@
+import type { ImageBuffer, ImageRaw } from './types';
+import type { Location, Size, Region } from '@applitools/utils';
+import type { Logger } from '@applitools/logger';
+export interface Image {
+    isImage: true;
+    size: Size;
+    unscaledSize: Size;
+    rawSize: Size;
+    transforms: Transforms;
+    width: number;
+    height: number;
+    scale(ratio: number): Image;
+    rotate(degrees: number): Image;
+    crop(region: any): Image;
+    copy(srcImage: Image, offset: any): Image;
+    frame(topImage: Image, bottomImage: Image, region: any): Image;
+    toRaw(): Promise<ImageRaw>;
+    toBuffer(): Promise<ImageBuffer>;
+    toPng(): Promise<ImageBuffer>;
+    toFile(path: string): Promise<void>;
+    toObject(): Promise<ImageRaw>;
+    debug(debug: any): Promise<void>;
+}
+type ImageSource = string | ArrayBuffer | ImageBuffer | Image | (Size & {
+    data?: ImageBuffer;
+}) | {
+    auto: true;
+};
+type Transforms = {
+    rotate: number;
+    scale: number;
+    crop?: Region;
+    modifiers: ({
+        type: 'copy';
+        image: Promise<ImageRaw>;
+        offset: Location;
+    } | {
+        type: 'frame';
+        top: Promise<ImageRaw>;
+        bottom: Promise<ImageRaw>;
+        region: Region;
+    })[];
+    added?: any;
+};
+export declare function makeImage(data: ImageSource, defaultLogger?: Logger): Image;
+export {};

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './image';
+export * from './formats/png';
+export * from './formats/jpeg';
+export * from './formats/bmp';
+export * from './formats/gif';

package/types/types.d.ts

@@ -0,0 +1,6 @@
+export type ImageBuffer = Uint8Array;
+export interface ImageRaw {
+    width: number;
+    height: number;
+    data: ImageBuffer;
+}