patchright-core 1.56.1 → 1.58.2

package/lib/server/trace/viewer/traceParser.js

@@ -0,0 +1,72 @@
+"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 traceParser_exports = {};
+__export(traceParser_exports, {
+  ZipTraceLoaderBackend: () => ZipTraceLoaderBackend
+});
+module.exports = __toCommonJS(traceParser_exports);
+var import_url = __toESM(require("url"));
+var import_zipFile = require("../../utils/zipFile");
+class ZipTraceLoaderBackend {
+  constructor(traceFile) {
+    this._traceFile = traceFile;
+    this._zipFile = new import_zipFile.ZipFile(traceFile);
+  }
+  isLive() {
+    return false;
+  }
+  traceURL() {
+    return import_url.default.pathToFileURL(this._traceFile).toString();
+  }
+  async entryNames() {
+    return await this._zipFile.entries();
+  }
+  async hasEntry(entryName) {
+    const entries = await this.entryNames();
+    return entries.includes(entryName);
+  }
+  async readText(entryName) {
+    try {
+      const buffer = await this._zipFile.read(entryName);
+      return buffer.toString("utf-8");
+    } catch {
+    }
+  }
+  async readBlob(entryName) {
+    try {
+      const buffer = await this._zipFile.read(entryName);
+      return new Blob([new Uint8Array(buffer)]);
+    } catch {
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZipTraceLoaderBackend
+});

package/lib/server/trace/viewer/traceViewer.js

@@ -46,13 +46,22 @@ var import_launchApp = require("../../launchApp");
 var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
 var import_progress = require("../../progress");
-function validateTraceUrls(traceUrls) {
-  for (const traceUrl of traceUrls) {
-    let traceFile = traceUrl;
-    if (traceUrl.endsWith(".json"))
-      traceFile = traceUrl.substring(0, traceUrl.length - ".json".length);
-    if (!traceUrl.startsWith("http://") && !traceUrl.startsWith("https://") && !import_fs.default.existsSync(traceFile) && !import_fs.default.existsSync(traceFile + ".trace"))
-      throw new Error(`Trace file ${traceUrl} does not exist!`);
+const tracesDirMarker = "traces.dir";
+function validateTraceUrlOrPath(traceFileOrUrl) {
+  if (!traceFileOrUrl)
+    return traceFileOrUrl;
+  if (traceFileOrUrl.startsWith("http://") || traceFileOrUrl.startsWith("https://"))
+    return traceFileOrUrl;
+  let traceFile = traceFileOrUrl;
+  if (traceFile.endsWith(".json"))
+    return toFilePathUrl(traceFile);
+  try {
+    const stat = import_fs.default.statSync(traceFile);
+    if (stat.isDirectory())
+      traceFile = import_path.default.join(traceFile, tracesDirMarker);
+    return toFilePathUrl(traceFile);
+  } catch {
+    throw new Error(`Trace file ${traceFileOrUrl} does not exist!`);
   }
 }
 async function startTraceViewerServer(options) {
@@ -60,24 +69,18 @@ async function startTraceViewerServer(options) {
   server.routePrefix("/trace", (request, response) => {
     const url = new URL("http://localhost" + request.url);
     const relativePath = url.pathname.slice("/trace".length);
-    if (process.env.PW_HMR) {
-      response.appendHeader("Access-Control-Allow-Origin", "http://localhost:44223");
-    }
-    if (relativePath.endsWith("/stall.js"))
-      return true;
     if (relativePath.startsWith("/file")) {
       try {
         const filePath = url.searchParams.get("path");
         if (import_fs.default.existsSync(filePath))
           return server.serveFile(request, response, url.searchParams.get("path"));
         if (filePath.endsWith(".json")) {
-          const traceName = filePath.substring(0, filePath.length - ".json".length);
-          response.statusCode = 200;
-          response.setHeader("Content-Type", "application/json");
-          response.end(JSON.stringify(traceDescriptor(traceName)));
-          return true;
+          const fullPrefix = filePath.substring(0, filePath.length - ".json".length);
+          return sendTraceDescriptor(response, import_path.default.dirname(fullPrefix), import_path.default.basename(fullPrefix));
         }
-      } catch (e) {
+        if (filePath.endsWith(tracesDirMarker))
+          return sendTraceDescriptor(response, import_path.default.dirname(filePath));
+      } catch {
       }
       response.statusCode = 404;
       response.end();
@@ -93,11 +96,11 @@ async function startTraceViewerServer(options) {
   await server.start({ preferredPort: port, host });
   return server;
 }
-async function installRootRedirect(server, traceUrls, options) {
+async function installRootRedirect(server, traceUrl, options) {
   const params = new URLSearchParams();
   if (import_path.default.sep !== import_path.default.posix.sep)
     params.set("pathSeparator", import_path.default.sep);
-  for (const traceUrl of traceUrls)
+  if (traceUrl)
     params.append("trace", traceUrl);
   if (server.wsGuid())
     params.append("ws", server.wsGuid());
@@ -115,12 +118,7 @@ async function installRootRedirect(server, traceUrls, options) {
     params.append("project", project);
   for (const reporter of options.reporter || [])
     params.append("reporter", reporter);
-  let baseUrl = ".";
-  if (process.env.PW_HMR) {
-    baseUrl = "http://localhost:44223";
-    params.set("server", server.urlPrefix("precise"));
-  }
-  const urlPath = `${baseUrl}/trace/${options.webApp || "index.html"}?${params.toString()}`;
+  const urlPath = `./trace/${options.webApp || "index.html"}?${params.toString()}`;
   server.routePath("/", (_, response) => {
     response.statusCode = 302;
     response.setHeader("Location", urlPath);
@@ -128,19 +126,19 @@ async function installRootRedirect(server, traceUrls, options) {
     return true;
   });
 }
-async function runTraceViewerApp(traceUrls, browserName, options, exitOnClose) {
-  validateTraceUrls(traceUrls);
+async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
-  await installRootRedirect(server, traceUrls, options);
+  await installRootRedirect(server, traceUrl, options);
   const page = await openTraceViewerApp(server.urlPrefix("precise"), browserName, options);
   if (exitOnClose)
     page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
   return page;
 }
-async function runTraceInBrowser(traceUrls, options) {
-  validateTraceUrls(traceUrls);
+async function runTraceInBrowser(traceUrl, options) {
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
-  await installRootRedirect(server, traceUrls, options);
+  await installRootRedirect(server, traceUrl, options);
   await openTraceInBrowser(server.urlPrefix("human-readable"));
 }
 async function openTraceViewerApp(url, browserName, options) {
@@ -180,8 +178,8 @@ async function openTraceInBrowser(url) {
 class StdinServer {
   constructor() {
     process.stdin.on("data", (data) => {
-      const url = data.toString().trim();
-      if (url === this._traceUrl)
+      const url = validateTraceUrlOrPath(data.toString().trim());
+      if (!url || url === this._traceUrl)
         return;
       if (url.endsWith(".json"))
         this._pollLoadTrace(url);
@@ -212,23 +210,30 @@ class StdinServer {
     }, 500);
   }
 }
-function traceDescriptor(traceName) {
+function sendTraceDescriptor(response, traceDir, tracePrefix) {
+  response.statusCode = 200;
+  response.setHeader("Content-Type", "application/json");
+  response.end(JSON.stringify(traceDescriptor(traceDir, tracePrefix)));
+  return true;
+}
+function traceDescriptor(traceDir, tracePrefix) {
   const result = {
     entries: []
   };
-  const traceDir = import_path.default.dirname(traceName);
-  const traceFile = import_path.default.basename(traceName);
   for (const name of import_fs.default.readdirSync(traceDir)) {
-    if (name.startsWith(traceFile))
-      result.entries.push({ name, path: import_path.default.join(traceDir, name) });
+    if (!tracePrefix || name.startsWith(tracePrefix))
+      result.entries.push({ name, path: toFilePathUrl(import_path.default.join(traceDir, name)) });
   }
   const resourcesDir = import_path.default.join(traceDir, "resources");
   if (import_fs.default.existsSync(resourcesDir)) {
     for (const name of import_fs.default.readdirSync(resourcesDir))
-      result.entries.push({ name: "resources/" + name, path: import_path.default.join(resourcesDir, name) });
+      result.entries.push({ name: "resources/" + name, path: toFilePathUrl(import_path.default.join(resourcesDir, name)) });
   }
   return result;
 }
+function toFilePathUrl(filePath) {
+  return `file?path=${encodeURIComponent(filePath)}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   installRootRedirect,

package/lib/server/utils/comparators.js

@@ -37,6 +37,7 @@ var import_pixelmatch = __toESM(require("../../third_party/pixelmatch"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_utilsBundle2 = require("../../utilsBundle");
 var import_utilsBundle3 = require("../../utilsBundle");
+var import_imageUtils = require("./imageUtils");
 function getComparator(mimeType) {
   if (mimeType === "image/png")
     return compareImages.bind(null, "image/png");
@@ -66,8 +67,8 @@ function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
   let sizesMismatchError = "";
   if (expected.width !== actual.width || expected.height !== actual.height) {
     sizesMismatchError = `Expected an image ${expected.width}px by ${expected.height}px, received ${actual.width}px by ${actual.height}px. `;
-    actual = resizeImage(actual, size);
-    expected = resizeImage(expected, size);
+    actual = (0, import_imageUtils.padImageToSize)(actual, size);
+    expected = (0, import_imageUtils.padImageToSize)(expected, size);
   }
   const diff2 = new import_utilsBundle3.PNG({ width: size.width, height: size.height });
   let count;
@@ -131,29 +132,6 @@ function compareText(actual, expectedBuffer) {
   const errorMessage = coloredLines.join("\n");
   return { errorMessage };
 }
-function resizeImage(image, size) {
-  if (image.width === size.width && image.height === size.height)
-    return image;
-  const buffer = new Uint8Array(size.width * size.height * 4);
-  for (let y = 0; y < size.height; y++) {
-    for (let x = 0; x < size.width; x++) {
-      const to = (y * size.width + x) * 4;
-      if (y < image.height && x < image.width) {
-        const from = (y * image.width + x) * 4;
-        buffer[to] = image.data[from];
-        buffer[to + 1] = image.data[from + 1];
-        buffer[to + 2] = image.data[from + 2];
-        buffer[to + 3] = image.data[from + 3];
-      } else {
-        buffer[to] = 0;
-        buffer[to + 1] = 0;
-        buffer[to + 2] = 0;
-        buffer[to + 3] = 0;
-      }
-    }
-  }
-  return { data: Buffer.from(buffer), width: size.width, height: size.height };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   compareBuffersOrStrings,

package/lib/server/utils/expectUtils.js

@@ -18,10 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var expectUtils_exports = {};
 __export(expectUtils_exports, {
-  serializeExpectedTextValues: () => serializeExpectedTextValues
+  callLogText: () => callLogText,
+  formatMatcherMessage: () => formatMatcherMessage,
+  printReceivedStringContainExpectedResult: () => printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring: () => printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues: () => serializeExpectedTextValues,
+  simpleMatcherUtils: () => simpleMatcherUtils
 });
 module.exports = __toCommonJS(expectUtils_exports);
 var import_rtti = require("../../utils/isomorphic/rtti");
+var import_utilsBundle = require("../../utilsBundle");
 function serializeExpectedTextValues(items, options = {}) {
   return items.map((i) => ({
     string: (0, import_rtti.isString)(i) ? i : void 0,
@@ -32,7 +38,86 @@ function serializeExpectedTextValues(items, options = {}) {
     normalizeWhiteSpace: options.normalizeWhiteSpace
   }));
 }
+const printSubstring = (val) => val.replace(/"|\\/g, "\\$&");
+const printReceivedStringContainExpectedSubstring = (utils, received, start, length) => utils.RECEIVED_COLOR(
+  '"' + printSubstring(received.slice(0, start)) + utils.INVERTED_COLOR(printSubstring(received.slice(start, start + length))) + printSubstring(received.slice(start + length)) + '"'
+);
+const printReceivedStringContainExpectedResult = (utils, received, result) => result === null ? utils.printReceived(received) : printReceivedStringContainExpectedSubstring(
+  utils,
+  received,
+  result.index,
+  result[0].length
+);
+function formatMatcherMessage(utils, details) {
+  const receiver = details.receiver ?? (details.locator ? "locator" : "page");
+  let message = utils.DIM_COLOR("expect(") + utils.RECEIVED_COLOR(receiver) + utils.DIM_COLOR(")" + (details.promise ? "." + details.promise : "") + (details.isNot ? ".not" : "") + ".") + details.matcherName + utils.DIM_COLOR("(") + utils.EXPECTED_COLOR(details.expectation) + utils.DIM_COLOR(")") + " failed\n\n";
+  const diffLines = details.printedDiff?.split("\n");
+  if (diffLines?.length === 2) {
+    details.printedExpected = diffLines[0];
+    details.printedReceived = diffLines[1];
+    details.printedDiff = void 0;
+  }
+  const align = !details.errorMessage && details.printedExpected?.startsWith("Expected:") && (!details.printedReceived || details.printedReceived.startsWith("Received:"));
+  if (details.locator)
+    message += `Locator: ${align ? " " : ""}${details.locator}
+`;
+  if (details.printedExpected)
+    message += details.printedExpected + "\n";
+  if (details.printedReceived)
+    message += details.printedReceived + "\n";
+  if (details.timedOut && details.timeout)
+    message += `Timeout: ${align ? " " : ""}${details.timeout}ms
+`;
+  if (details.printedDiff)
+    message += details.printedDiff + "\n";
+  if (details.errorMessage) {
+    message += details.errorMessage;
+    if (!details.errorMessage.endsWith("\n"))
+      message += "\n";
+  }
+  message += callLogText(utils, details.log);
+  return message;
+}
+const callLogText = (utils, log) => {
+  if (!log || !log.some((l) => !!l))
+    return "";
+  return `
+Call log:
+${utils.DIM_COLOR(log.join("\n"))}
+`;
+};
+function printValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function printReceived(value) {
+  return import_utilsBundle.colors.red(printValue(value));
+}
+function printExpected(value) {
+  return import_utilsBundle.colors.green(printValue(value));
+}
+const simpleMatcherUtils = {
+  DIM_COLOR: import_utilsBundle.colors.dim,
+  RECEIVED_COLOR: import_utilsBundle.colors.red,
+  EXPECTED_COLOR: import_utilsBundle.colors.green,
+  INVERTED_COLOR: import_utilsBundle.colors.inverse,
+  printReceived,
+  printExpected,
+  printDiffOrStringify: (expected, received, expectedLabel, receivedLabel) => {
+    const maxLength = Math.max(expectedLabel.length, receivedLabel.length) + 2;
+    return `${expectedLabel}: `.padEnd(maxLength) + printExpected(expected) + `
+` + `${receivedLabel}: `.padEnd(maxLength) + printReceived(received);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  serializeExpectedTextValues
+  callLogText,
+  formatMatcherMessage,
+  printReceivedStringContainExpectedResult,
+  printReceivedStringContainExpectedSubstring,
+  serializeExpectedTextValues,
+  simpleMatcherUtils
 });

package/lib/server/utils/hostPlatform.js

@@ -28,10 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var hostPlatform_exports = {};
 __export(hostPlatform_exports, {
+  hasGpuMac: () => hasGpuMac,
   hostPlatform: () => hostPlatform,
-  isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform
+  isOfficiallySupportedPlatform: () => isOfficiallySupportedPlatform,
+  shortPlatform: () => shortPlatform
 });
 module.exports = __toCommonJS(hostPlatform_exports);
+var import_child_process = require("child_process");
 var import_os = __toESM(require("os"));
 var import_linuxUtils = require("./linuxUtils");
 function calculatePlatform() {
@@ -97,15 +100,39 @@ function calculatePlatform() {
       if (distroInfo?.version === "")
         return { hostPlatform: "debian13" + archSuffix, isOfficiallySupportedPlatform: isOfficiallySupportedPlatform2 };
     }
-    return { hostPlatform: "ubuntu20.04" + archSuffix, isOfficiallySupportedPlatform: false };
+    return { hostPlatform: "ubuntu24.04" + archSuffix, isOfficiallySupportedPlatform: false };
   }
   if (platform === "win32")
     return { hostPlatform: "win64", isOfficiallySupportedPlatform: true };
   return { hostPlatform: "<unknown>", isOfficiallySupportedPlatform: false };
 }
 const { hostPlatform, isOfficiallySupportedPlatform } = calculatePlatform();
+function toShortPlatform(hostPlatform2) {
+  if (hostPlatform2 === "<unknown>")
+    return "<unknown>";
+  if (hostPlatform2 === "win64")
+    return "win-x64";
+  if (hostPlatform2.startsWith("mac"))
+    return hostPlatform2.endsWith("arm64") ? "mac-arm64" : "mac-x64";
+  return hostPlatform2.endsWith("arm64") ? "linux-arm64" : "linux-x64";
+}
+const shortPlatform = toShortPlatform(hostPlatform);
+let hasGpuMacValue;
+function hasGpuMac() {
+  try {
+    if (hasGpuMacValue === void 0) {
+      const output = (0, import_child_process.execSync)("system_profiler SPDisplaysDataType", { stdio: ["ignore", "pipe", "ignore"] }).toString();
+      hasGpuMacValue = output.includes("Metal: Supported") || output.includes("Metal Support: Metal");
+    }
+    return hasGpuMacValue;
+  } catch (e) {
+    return false;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  hasGpuMac,
   hostPlatform,
-  isOfficiallySupportedPlatform
+  isOfficiallySupportedPlatform,
+  shortPlatform
 });

package/lib/server/utils/httpServer.js

@@ -36,7 +36,6 @@ var import_path = __toESM(require("path"));
 var import_utilsBundle = require("../../utilsBundle");
 var import_crypto = require("./crypto");
 var import_assert = require("../../utils/isomorphic/assert");
-var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 var import_network = require("./network");
 class HttpServer {
   constructor() {
@@ -59,20 +58,6 @@ class HttpServer {
   port() {
     return this._port;
   }
-  async _tryStart(port, host) {
-    const errorPromise = new import_manualPromise.ManualPromise();
-    const errorListener = (error) => errorPromise.reject(error);
-    this._server.on("error", errorListener);
-    try {
-      this._server.listen(port, host);
-      await Promise.race([
-        new Promise((cb) => this._server.once("listening", cb)),
-        errorPromise
-      ]);
-    } finally {
-      this._server.removeListener("error", errorListener);
-    }
-  }
   createWebSocket(transport, guid) {
     (0, import_assert.assert)(!this._wsGuid, "can only create one main websocket transport per server");
     this._wsGuid = guid || (0, import_crypto.createGuid)();
@@ -100,17 +85,17 @@ class HttpServer {
   async start(options = {}) {
     (0, import_assert.assert)(!this._started, "server already started");
     this._started = true;
-    const host = options.host || "localhost";
+    const host = options.host;
     if (options.preferredPort) {
       try {
-        await this._tryStart(options.preferredPort, host);
+        await (0, import_network.startHttpServer)(this._server, { port: options.preferredPort, host });
       } catch (e) {
         if (!e || !e.message || !e.message.includes("EADDRINUSE"))
           throw e;
-        await this._tryStart(void 0, host);
+        await (0, import_network.startHttpServer)(this._server, { host });
       }
     } else {
-      await this._tryStart(options.port, host);
+      await (0, import_network.startHttpServer)(this._server, { port: options.port, host });
     }
     const address = this._server.address();
     (0, import_assert.assert)(address, "Could not bind server socket");
@@ -121,7 +106,7 @@ class HttpServer {
       this._port = address.port;
       const resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
       this._urlPrefixPrecise = `http://${resolvedHost}:${address.port}`;
-      this._urlPrefixHumanReadable = `http://${host}:${address.port}`;
+      this._urlPrefixHumanReadable = `http://${host ?? "localhost"}:${address.port}`;
     }
   }
   async stop() {

package/lib/server/utils/imageUtils.js

@@ -0,0 +1,141 @@
+"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 imageUtils_exports = {};
+__export(imageUtils_exports, {
+  padImageToSize: () => padImageToSize,
+  scaleImageToSize: () => scaleImageToSize
+});
+module.exports = __toCommonJS(imageUtils_exports);
+function padImageToSize(image, size) {
+  if (image.width === size.width && image.height === size.height)
+    return image;
+  const buffer = new Uint8Array(size.width * size.height * 4);
+  for (let y = 0; y < size.height; y++) {
+    for (let x = 0; x < size.width; x++) {
+      const to = (y * size.width + x) * 4;
+      if (y < image.height && x < image.width) {
+        const from = (y * image.width + x) * 4;
+        buffer[to] = image.data[from];
+        buffer[to + 1] = image.data[from + 1];
+        buffer[to + 2] = image.data[from + 2];
+        buffer[to + 3] = image.data[from + 3];
+      } else {
+        buffer[to] = 0;
+        buffer[to + 1] = 0;
+        buffer[to + 2] = 0;
+        buffer[to + 3] = 0;
+      }
+    }
+  }
+  return { data: Buffer.from(buffer), width: size.width, height: size.height };
+}
+function scaleImageToSize(image, size) {
+  const { data: src, width: w1, height: h1 } = image;
+  const w2 = Math.max(1, Math.floor(size.width));
+  const h2 = Math.max(1, Math.floor(size.height));
+  if (w1 === w2 && h1 === h2)
+    return image;
+  if (w1 <= 0 || h1 <= 0)
+    throw new Error("Invalid input image");
+  if (size.width <= 0 || size.height <= 0 || !isFinite(size.width) || !isFinite(size.height))
+    throw new Error("Invalid output dimensions");
+  const clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+  const weights = (t, o) => {
+    const t2 = t * t, t3 = t2 * t;
+    o[0] = -0.5 * t + 1 * t2 - 0.5 * t3;
+    o[1] = 1 - 2.5 * t2 + 1.5 * t3;
+    o[2] = 0.5 * t + 2 * t2 - 1.5 * t3;
+    o[3] = -0.5 * t2 + 0.5 * t3;
+  };
+  const srcRowStride = w1 * 4;
+  const dstRowStride = w2 * 4;
+  const xOff = new Int32Array(w2 * 4);
+  const xW = new Float32Array(w2 * 4);
+  const wx = new Float32Array(4);
+  const xScale = w1 / w2;
+  for (let x = 0; x < w2; x++) {
+    const sx = (x + 0.5) * xScale - 0.5;
+    const sxi = Math.floor(sx);
+    const t = sx - sxi;
+    weights(t, wx);
+    const b = x * 4;
+    const i0 = clamp(sxi - 1, 0, w1 - 1);
+    const i1 = clamp(sxi + 0, 0, w1 - 1);
+    const i2 = clamp(sxi + 1, 0, w1 - 1);
+    const i3 = clamp(sxi + 2, 0, w1 - 1);
+    xOff[b + 0] = i0 << 2;
+    xOff[b + 1] = i1 << 2;
+    xOff[b + 2] = i2 << 2;
+    xOff[b + 3] = i3 << 2;
+    xW[b + 0] = wx[0];
+    xW[b + 1] = wx[1];
+    xW[b + 2] = wx[2];
+    xW[b + 3] = wx[3];
+  }
+  const yRow = new Int32Array(h2 * 4);
+  const yW = new Float32Array(h2 * 4);
+  const wy = new Float32Array(4);
+  const yScale = h1 / h2;
+  for (let y = 0; y < h2; y++) {
+    const sy = (y + 0.5) * yScale - 0.5;
+    const syi = Math.floor(sy);
+    const t = sy - syi;
+    weights(t, wy);
+    const b = y * 4;
+    const j0 = clamp(syi - 1, 0, h1 - 1);
+    const j1 = clamp(syi + 0, 0, h1 - 1);
+    const j2 = clamp(syi + 1, 0, h1 - 1);
+    const j3 = clamp(syi + 2, 0, h1 - 1);
+    yRow[b + 0] = j0 * srcRowStride;
+    yRow[b + 1] = j1 * srcRowStride;
+    yRow[b + 2] = j2 * srcRowStride;
+    yRow[b + 3] = j3 * srcRowStride;
+    yW[b + 0] = wy[0];
+    yW[b + 1] = wy[1];
+    yW[b + 2] = wy[2];
+    yW[b + 3] = wy[3];
+  }
+  const dst = new Uint8Array(w2 * h2 * 4);
+  for (let y = 0; y < h2; y++) {
+    const yb = y * 4;
+    const rb0 = yRow[yb + 0], rb1 = yRow[yb + 1], rb2 = yRow[yb + 2], rb3 = yRow[yb + 3];
+    const wy0 = yW[yb + 0], wy1 = yW[yb + 1], wy2 = yW[yb + 2], wy3 = yW[yb + 3];
+    const dstBase = y * dstRowStride;
+    for (let x = 0; x < w2; x++) {
+      const xb = x * 4;
+      const xo0 = xOff[xb + 0], xo1 = xOff[xb + 1], xo2 = xOff[xb + 2], xo3 = xOff[xb + 3];
+      const wx0 = xW[xb + 0], wx1 = xW[xb + 1], wx2 = xW[xb + 2], wx3 = xW[xb + 3];
+      const di = dstBase + (x << 2);
+      for (let c = 0; c < 4; c++) {
+        const r0 = src[rb0 + xo0 + c] * wx0 + src[rb0 + xo1 + c] * wx1 + src[rb0 + xo2 + c] * wx2 + src[rb0 + xo3 + c] * wx3;
+        const r1 = src[rb1 + xo0 + c] * wx0 + src[rb1 + xo1 + c] * wx1 + src[rb1 + xo2 + c] * wx2 + src[rb1 + xo3 + c] * wx3;
+        const r2 = src[rb2 + xo0 + c] * wx0 + src[rb2 + xo1 + c] * wx1 + src[rb2 + xo2 + c] * wx2 + src[rb2 + xo3 + c] * wx3;
+        const r3 = src[rb3 + xo0 + c] * wx0 + src[rb3 + xo1 + c] * wx1 + src[rb3 + xo2 + c] * wx2 + src[rb3 + xo3 + c] * wx3;
+        const v = r0 * wy0 + r1 * wy1 + r2 * wy2 + r3 * wy3;
+        dst[di + c] = v < 0 ? 0 : v > 255 ? 255 : v | 0;
+      }
+    }
+  }
+  return { data: Buffer.from(dst.buffer), width: w2, height: h2 };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  padImageToSize,
+  scaleImageToSize
+});