playwright-codegen-pro-core 1.0.0

package/lib/server/webkit/wkProvisionalPage.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wkProvisionalPage_exports = {};
+__export(wkProvisionalPage_exports, {
+  WKProvisionalPage: () => WKProvisionalPage
+});
+module.exports = __toCommonJS(wkProvisionalPage_exports);
+var import_utils = require("../../utils");
+var import_eventsHelper = require("../utils/eventsHelper");
+class WKProvisionalPage {
+  constructor(session, page) {
+    this._sessionListeners = [];
+    this._mainFrameId = null;
+    this._session = session;
+    this._wkPage = page;
+    this._coopNavigationRequest = page._page.mainFrame().pendingDocument()?.request;
+    const overrideFrameId = (handler) => {
+      return (payload) => {
+        if (payload.frameId)
+          payload.frameId = this._wkPage._page.frameManager.mainFrame()._id;
+        handler(payload);
+      };
+    };
+    const wkPage = this._wkPage;
+    this._sessionListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(session, "Network.requestWillBeSent", overrideFrameId((e) => this._onRequestWillBeSent(e))),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Network.requestIntercepted", overrideFrameId((e) => wkPage._onRequestIntercepted(session, e))),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Network.responseReceived", overrideFrameId((e) => wkPage._onResponseReceived(session, e))),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Network.loadingFinished", overrideFrameId((e) => this._onLoadingFinished(e))),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Network.loadingFailed", overrideFrameId((e) => this._onLoadingFailed(e)))
+    ];
+    this.initializationPromise = this._wkPage._initializeSession(session, true, ({ frameTree }) => this._handleFrameTree(frameTree));
+  }
+  coopNavigationRequest() {
+    return this._coopNavigationRequest;
+  }
+  dispose() {
+    import_eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+  }
+  commit() {
+    (0, import_utils.assert)(this._mainFrameId);
+    this._wkPage._onFrameAttached(this._mainFrameId, null);
+  }
+  _onRequestWillBeSent(event) {
+    if (this._coopNavigationRequest && this._coopNavigationRequest.url() === event.request.url) {
+      this._wkPage._adoptRequestFromNewProcess(this._coopNavigationRequest, this._session, event.requestId);
+      return;
+    }
+    this._wkPage._onRequestWillBeSent(this._session, event);
+  }
+  _onLoadingFinished(event) {
+    this._coopNavigationRequest = void 0;
+    this._wkPage._onLoadingFinished(event);
+  }
+  _onLoadingFailed(event) {
+    this._coopNavigationRequest = void 0;
+    this._wkPage._onLoadingFailed(this._session, event);
+  }
+  _handleFrameTree(frameTree) {
+    (0, import_utils.assert)(!frameTree.frame.parentId);
+    this._mainFrameId = frameTree.frame.id;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WKProvisionalPage
+});

package/lib/server/webkit/wkWorkers.js

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wkWorkers_exports = {};
+__export(wkWorkers_exports, {
+  WKWorkers: () => WKWorkers
+});
+module.exports = __toCommonJS(wkWorkers_exports);
+var import_eventsHelper = require("../utils/eventsHelper");
+var import_page = require("../page");
+var import_wkConnection = require("./wkConnection");
+var import_wkExecutionContext = require("./wkExecutionContext");
+class WKWorkers {
+  constructor(page) {
+    this._sessionListeners = [];
+    this._workerSessions = /* @__PURE__ */ new Map();
+    this._page = page;
+  }
+  setSession(session) {
+    import_eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+    this.clear();
+    this._sessionListeners = [
+      import_eventsHelper.eventsHelper.addEventListener(session, "Worker.workerCreated", (event) => {
+        const worker = new import_page.Worker(this._page, event.url);
+        const workerSession = new import_wkConnection.WKSession(session.connection, event.workerId, (message) => {
+          session.send("Worker.sendMessageToWorker", {
+            workerId: event.workerId,
+            message: JSON.stringify(message)
+          }).catch((e) => {
+            workerSession.dispatchMessage({ id: message.id, error: { message: e.message } });
+          });
+        });
+        this._workerSessions.set(event.workerId, workerSession);
+        worker.createExecutionContext(new import_wkExecutionContext.WKExecutionContext(workerSession, void 0));
+        worker.workerScriptLoaded();
+        this._page.addWorker(event.workerId, worker);
+        workerSession.on("Console.messageAdded", (event2) => this._onConsoleMessage(worker, event2));
+        Promise.all([
+          workerSession.send("Runtime.enable"),
+          workerSession.send("Console.enable"),
+          session.send("Worker.initialized", { workerId: event.workerId })
+        ]).catch((e) => {
+          this._page.removeWorker(event.workerId);
+        });
+      }),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Worker.dispatchMessageFromWorker", (event) => {
+        const workerSession = this._workerSessions.get(event.workerId);
+        if (!workerSession)
+          return;
+        workerSession.dispatchMessage(JSON.parse(event.message));
+      }),
+      import_eventsHelper.eventsHelper.addEventListener(session, "Worker.workerTerminated", (event) => {
+        const workerSession = this._workerSessions.get(event.workerId);
+        if (!workerSession)
+          return;
+        workerSession.dispose();
+        this._workerSessions.delete(event.workerId);
+        this._page.removeWorker(event.workerId);
+      })
+    ];
+  }
+  clear() {
+    this._page.clearWorkers();
+    this._workerSessions.clear();
+  }
+  async initializeSession(session) {
+    await session.send("Worker.enable");
+  }
+  async _onConsoleMessage(worker, event) {
+    const { type, level, text, parameters, url, line: lineNumber, column: columnNumber } = event.message;
+    let derivedType = type || "";
+    if (type === "log")
+      derivedType = level;
+    else if (type === "timing")
+      derivedType = "timeEnd";
+    const handles = (parameters || []).map((p) => {
+      return (0, import_wkExecutionContext.createHandle)(worker.existingExecutionContext, p);
+    });
+    const location = {
+      url: url || "",
+      lineNumber: (lineNumber || 1) - 1,
+      columnNumber: (columnNumber || 1) - 1
+    };
+    const timestamp = event.message.timestamp ? event.message.timestamp * 1e3 : Date.now();
+    this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? void 0 : text, timestamp);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WKWorkers
+});

package/lib/serverRegistry.js

@@ -0,0 +1,147 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serverRegistry_exports = {};
+__export(serverRegistry_exports, {
+  serverRegistry: () => serverRegistry
+});
+module.exports = __toCommonJS(serverRegistry_exports);
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+const packageVersion = require("../package.json").version;
+class ServerRegistry {
+  async list() {
+    const files = await import_fs.default.promises.readdir(this._browsersDir()).catch(() => []);
+    const result = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      try {
+        const filePath = import_path.default.join(this._browsersDir(), file);
+        const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+        const descriptor = JSON.parse(content);
+        const key = descriptor.workspaceDir ?? "";
+        let list = result.get(key);
+        if (!list) {
+          list = [];
+          result.set(key, list);
+        }
+        list.push(canConnect(descriptor).then((connectable) => ({ ...descriptor, canConnect: connectable, file: filePath })));
+      } catch {
+      }
+    }
+    const resolvedResult = /* @__PURE__ */ new Map();
+    for (const [key, promises] of result) {
+      const entries = await Promise.all(promises);
+      const descriptors = [];
+      for (const entry of entries) {
+        if (!entry.canConnect && !entry.browser.userDataDir) {
+          await import_fs.default.promises.unlink(entry.file).catch(() => {
+          });
+          continue;
+        }
+        descriptors.push(entry);
+      }
+      if (descriptors.length)
+        resolvedResult.set(key, descriptors);
+    }
+    return resolvedResult;
+  }
+  async create(browser, endpoint) {
+    const file = import_path.default.join(this._browsersDir(), browser.guid);
+    await import_fs.default.promises.mkdir(this._browsersDir(), { recursive: true });
+    const descriptor = {
+      playwrightVersion: packageVersion,
+      playwrightLib: require.resolve(".."),
+      title: endpoint.title,
+      browser,
+      pipeName: endpoint.pipeName,
+      workspaceDir: endpoint.workspaceDir
+    };
+    await import_fs.default.promises.writeFile(file, JSON.stringify(descriptor), "utf-8");
+  }
+  async delete(guid) {
+    const file = import_path.default.join(this._browsersDir(), guid);
+    await import_fs.default.promises.unlink(file).catch(() => {
+    });
+  }
+  async deleteUserData(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = await import_fs.default.promises.readFile(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    if (descriptor.browser.userDataDir)
+      await import_fs.default.promises.rm(descriptor.browser.userDataDir, { recursive: true, force: true });
+    await import_fs.default.promises.unlink(filePath);
+  }
+  readDescriptor(guid) {
+    const filePath = import_path.default.join(this._browsersDir(), guid);
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const descriptor = JSON.parse(content);
+    return descriptor;
+  }
+  async find(name) {
+    const entries = await this.list();
+    for (const [, browsers] of entries) {
+      for (const browser of browsers) {
+        if (browser.title === name)
+          return browser;
+      }
+    }
+    return null;
+  }
+  _browsersDir() {
+    return process.env.PLAYWRIGHT_SERVER_REGISTRY || registryDirectory;
+  }
+}
+async function canConnect(descriptor) {
+  if (descriptor.pipeName) {
+    return await new Promise((resolve) => {
+      const socket = import_net.default.createConnection(descriptor.pipeName, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on("error", () => resolve(false));
+    });
+  }
+  return false;
+}
+const defaultCacheDirectory = (() => {
+  if (process.platform === "linux")
+    return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    return import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  throw new Error("Unsupported platform: " + process.platform);
+})();
+const registryDirectory = import_path.default.join(defaultCacheDirectory, "ms-playwright", "b");
+const serverRegistry = new ServerRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serverRegistry
+});

package/lib/third_party/pixelmatch.js

@@ -0,0 +1,255 @@
+/**
+ * 
+ * ISC License
+ *
+ * Copyright (c) 2019, Mapbox
+
+ * Permission to use, copy, modify, and/or distribute this software for any purpose
+ * with or without fee is hereby granted, provided that the above copyright notice
+ * and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+'use strict';
+
+module.exports = pixelmatch;
+
+const defaultOptions = {
+    threshold: 0.1,         // matching threshold (0 to 1); smaller is more sensitive
+    includeAA: false,       // whether to skip anti-aliasing detection
+    alpha: 0.1,             // opacity of original image in diff output
+    aaColor: [255, 255, 0], // color of anti-aliased pixels in diff output
+    diffColor: [255, 0, 0], // color of different pixels in diff output
+    diffColorAlt: null,     // whether to detect dark on light differences between img1 and img2 and set an alternative color to differentiate between the two
+    diffMask: false         // draw the diff over a transparent background (a mask)
+};
+
+function pixelmatch(img1, img2, output, width, height, options) {
+
+    if (!isPixelData(img1) || !isPixelData(img2) || (output && !isPixelData(output)))
+        throw new Error('Image data: Uint8Array, Uint8ClampedArray or Buffer expected.');
+
+    if (img1.length !== img2.length || (output && output.length !== img1.length))
+        throw new Error('Image sizes do not match.');
+
+    if (img1.length !== width * height * 4) throw new Error('Image data size does not match width/height.');
+
+    options = Object.assign({}, defaultOptions, options);
+
+    // check if images are identical
+    const len = width * height;
+    const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+    const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+    let identical = true;
+
+    for (let i = 0; i < len; i++) {
+        if (a32[i] !== b32[i]) { identical = false; break; }
+    }
+    if (identical) { // fast path if identical
+        if (output && !options.diffMask) {
+            for (let i = 0; i < len; i++) drawGrayPixel(img1, 4 * i, options.alpha, output);
+        }
+        return 0;
+    }
+
+    // maximum acceptable square distance between two colors;
+    // 35215 is the maximum possible value for the YIQ difference metric
+    const maxDelta = 35215 * options.threshold * options.threshold;
+    let diff = 0;
+
+    // compare each pixel of one image against the other one
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+
+            const pos = (y * width + x) * 4;
+
+            // squared YUV distance between colors at this pixel position, negative if the img2 pixel is darker
+            const delta = colorDelta(img1, img2, pos, pos);
+
+            // the color difference is above the threshold
+            if (Math.abs(delta) > maxDelta) {
+                // check it's a real rendering difference or just anti-aliasing
+                if (!options.includeAA && (antialiased(img1, x, y, width, height, img2) ||
+                                           antialiased(img2, x, y, width, height, img1))) {
+                    // one of the pixels is anti-aliasing; draw as yellow and do not count as difference
+                    // note that we do not include such pixels in a mask
+                    if (output && !options.diffMask) drawPixel(output, pos, ...options.aaColor);
+
+                } else {
+                    // found substantial difference not caused by anti-aliasing; draw it as such
+                    if (output) {
+                        drawPixel(output, pos, ...(delta < 0 && options.diffColorAlt || options.diffColor));
+                    }
+                    diff++;
+                }
+
+            } else if (output) {
+                // pixels are similar; draw background as grayscale image blended with white
+                if (!options.diffMask) drawGrayPixel(img1, pos, options.alpha, output);
+            }
+        }
+    }
+
+    // return the number of different pixels
+    return diff;
+}
+
+function isPixelData(arr) {
+    // work around instanceof Uint8Array not working properly in some Jest environments
+    return ArrayBuffer.isView(arr) && arr.constructor.BYTES_PER_ELEMENT === 1;
+}
+
+// check if a pixel is likely a part of anti-aliasing;
+// based on "Anti-aliased Pixel and Intensity Slope Detector" paper by V. Vysniauskas, 2009
+
+function antialiased(img, x1, y1, width, height, img2) {
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+    let min = 0;
+    let max = 0;
+    let minX, minY, maxX, maxY;
+
+    // go through 8 adjacent pixels
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
+            if (x === x1 && y === y1) continue;
+
+            // brightness delta between the center pixel and adjacent one
+            const delta = colorDelta(img, img, pos, (y * width + x) * 4, true);
+
+            // count the number of equal, darker and brighter adjacent pixels
+            if (delta === 0) {
+                zeroes++;
+                // if found more than 2 equal siblings, it's definitely not anti-aliasing
+                if (zeroes > 2) return false;
+
+            // remember the darkest pixel
+            } else if (delta < min) {
+                min = delta;
+                minX = x;
+                minY = y;
+
+            // remember the brightest pixel
+            } else if (delta > max) {
+                max = delta;
+                maxX = x;
+                maxY = y;
+            }
+        }
+    }
+
+    // if there are no both darker and brighter pixels among siblings, it's not anti-aliasing
+    if (min === 0 || max === 0) return false;
+
+    // if either the darkest or the brightest pixel has 3+ equal siblings in both images
+    // (definitely not anti-aliased), this pixel is anti-aliased
+    return (hasManySiblings(img, minX, minY, width, height) && hasManySiblings(img2, minX, minY, width, height)) ||
+           (hasManySiblings(img, maxX, maxY, width, height) && hasManySiblings(img2, maxX, maxY, width, height));
+}
+
+// check if a pixel has 3+ adjacent pixels of the same color.
+function hasManySiblings(img, x1, y1, width, height) {
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+
+    // go through 8 adjacent pixels
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
+            if (x === x1 && y === y1) continue;
+
+            const pos2 = (y * width + x) * 4;
+            if (img[pos] === img[pos2] &&
+                img[pos + 1] === img[pos2 + 1] &&
+                img[pos + 2] === img[pos2 + 2] &&
+                img[pos + 3] === img[pos2 + 3]) zeroes++;
+
+            if (zeroes > 2) return true;
+        }
+    }
+
+    return false;
+}
+
+// calculate color difference according to the paper "Measuring perceived color difference
+// using YIQ NTSC transmission color space in mobile applications" by Y. Kotsarenko and F. Ramos
+
+function colorDelta(img1, img2, k, m, yOnly) {
+    let r1 = img1[k + 0];
+    let g1 = img1[k + 1];
+    let b1 = img1[k + 2];
+    let a1 = img1[k + 3];
+
+    let r2 = img2[m + 0];
+    let g2 = img2[m + 1];
+    let b2 = img2[m + 2];
+    let a2 = img2[m + 3];
+
+    if (a1 === a2 && r1 === r2 && g1 === g2 && b1 === b2) return 0;
+
+    if (a1 < 255) {
+        a1 /= 255;
+        r1 = blend(r1, a1);
+        g1 = blend(g1, a1);
+        b1 = blend(b1, a1);
+    }
+
+    if (a2 < 255) {
+        a2 /= 255;
+        r2 = blend(r2, a2);
+        g2 = blend(g2, a2);
+        b2 = blend(b2, a2);
+    }
+
+    const y1 = rgb2y(r1, g1, b1);
+    const y2 = rgb2y(r2, g2, b2);
+    const y = y1 - y2;
+
+    if (yOnly) return y; // brightness difference only
+
+    const i = rgb2i(r1, g1, b1) - rgb2i(r2, g2, b2);
+    const q = rgb2q(r1, g1, b1) - rgb2q(r2, g2, b2);
+
+    const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
+
+    // encode whether the pixel lightens or darkens in the sign
+    return y1 > y2 ? -delta : delta;
+}
+
+function rgb2y(r, g, b) { return r * 0.29889531 + g * 0.58662247 + b * 0.11448223; }
+function rgb2i(r, g, b) { return r * 0.59597799 - g * 0.27417610 - b * 0.32180189; }
+function rgb2q(r, g, b) { return r * 0.21147017 - g * 0.52261711 + b * 0.31114694; }
+
+// blend semi-transparent color with white
+function blend(c, a) {
+    return 255 + (c - 255) * a;
+}
+
+function drawPixel(output, pos, r, g, b) {
+    output[pos + 0] = r;
+    output[pos + 1] = g;
+    output[pos + 2] = b;
+    output[pos + 3] = 255;
+}
+
+function drawGrayPixel(img, i, alpha, output) {
+    const r = img[i + 0];
+    const g = img[i + 1];
+    const b = img[i + 2];
+    const val = blend(rgb2y(r, g, b), alpha * img[i + 3] / 255);
+    drawPixel(output, i, val, val, val);
+}

package/lib/tools/backend/browserBackend.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserBackend_exports = {};
+__export(browserBackend_exports, {
+  BrowserBackend: () => BrowserBackend
+});
+module.exports = __toCommonJS(browserBackend_exports);
+var import_context = require("./context");
+var import_response = require("./response");
+var import_sessionLog = require("./sessionLog");
+var import_utilsBundle = require("../../utilsBundle");
+class BrowserBackend {
+  constructor(config, browserContext, tools) {
+    this._config = config;
+    this._tools = tools;
+    this.browserContext = browserContext;
+  }
+  async initialize(clientInfo) {
+    this._sessionLog = this._config.saveSession ? await import_sessionLog.SessionLog.create(this._config, clientInfo.cwd) : void 0;
+    this._context = new import_context.Context(this.browserContext, {
+      config: this._config,
+      sessionLog: this._sessionLog,
+      cwd: clientInfo.cwd
+    });
+  }
+  async dispose() {
+    await this._context?.dispose().catch((e) => (0, import_utilsBundle.debug)("pw:tools:error")(e));
+  }
+  async callTool(name, rawArguments = {}) {
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool) {
+      return {
+        content: [{ type: "text", text: `### Error
+Tool "${name}" not found` }],
+        isError: true
+      };
+    }
+    const parsedArguments = tool.schema.inputSchema.parse(rawArguments);
+    const cwd = rawArguments._meta?.cwd;
+    const context = this._context;
+    const response = new import_response.Response(context, name, parsedArguments, cwd);
+    context.setRunningTool(name);
+    let responseObject;
+    try {
+      await tool.handle(context, parsedArguments, response);
+      responseObject = await response.serialize();
+      this._sessionLog?.logResponse(name, parsedArguments, responseObject);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `### Error
+${String(error)}` }],
+        isError: true
+      };
+    } finally {
+      context.setRunningTool(void 0);
+    }
+    return responseObject;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBackend
+});