patchright-core 1.57.0 → 1.59.0

package/lib/server/registry/nativeDeps.js

@@ -496,6 +496,7 @@ const deps = {
     firefox: [
       "libasound2t64",
       "libatk1.0-0t64",
+      "libavcodec60",
       "libcairo-gobject2",
       "libcairo2",
       "libdbus-1-3",

package/lib/server/registry/oopDownloadBrowserMain.js

@@ -29,6 +29,7 @@ var import_path = __toESM(require("path"));
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
 var import_network = require("../utils/network");
 var import_zipBundle = require("../../zipBundle");
+var import_fileUtils = require("../utils/fileUtils");
 function log(message) {
   process.send?.({ method: "log", params: { message } });
 }
@@ -99,6 +100,8 @@ function downloadFile(options) {
 async function main(options) {
   await downloadFile(options);
   log(`SUCCESS downloading ${options.title}`);
+  log(`removing existing browser directory if any`);
+  await (0, import_fileUtils.removeFolders)([options.browserDirectory]);
   log(`extracting archive`);
   await (0, import_zipBundle.extract)(options.zipPath, { dir: options.browserDirectory });
   if (options.executablePath) {

package/lib/server/screencast.js

@@ -0,0 +1,137 @@
+"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 screencast_exports = {};
+__export(screencast_exports, {
+  Screencast: () => Screencast
+});
+module.exports = __toCommonJS(screencast_exports);
+var import_utils = require("../utils");
+var import_utils2 = require("../utils");
+class Screencast {
+  constructor(page) {
+    this._clients = /* @__PURE__ */ new Set();
+    this.page = page;
+    this.page.instrumentation.addListener(this, page.browserContext);
+  }
+  async handlePageOrContextClose() {
+    const clients = [...this._clients];
+    this._clients.clear();
+    for (const client of clients) {
+      if (client.gracefulClose)
+        await client.gracefulClose();
+    }
+  }
+  dispose() {
+    for (const client of this._clients)
+      client.dispose();
+    this._clients.clear();
+    this.page.instrumentation.removeListener(this);
+  }
+  showActions(options) {
+    this._actions = options;
+  }
+  hideActions() {
+    this._actions = void 0;
+  }
+  addClient(client) {
+    this._clients.add(client);
+    if (this._clients.size === 1)
+      this._startScreencast(client.size, client.quality);
+    return { size: this._size };
+  }
+  removeClient(client) {
+    if (!this._clients.has(client))
+      return;
+    this._clients.delete(client);
+    if (!this._clients.size)
+      this._stopScreencast();
+  }
+  size() {
+    return this._size;
+  }
+  _startScreencast(size, quality) {
+    this._size = size;
+    if (!this._size) {
+      const viewport = this.page.browserContext._options.viewport || { width: 800, height: 600 };
+      const scale = Math.min(1, 800 / Math.max(viewport.width, viewport.height));
+      this._size = {
+        width: Math.floor(viewport.width * scale),
+        height: Math.floor(viewport.height * scale)
+      };
+    }
+    this._size = {
+      width: this._size.width & ~1,
+      height: this._size.height & ~1
+    };
+    this.page.delegate.startScreencast({
+      width: this._size.width,
+      height: this._size.height,
+      quality: quality ?? 90
+    });
+  }
+  _stopScreencast() {
+    this.page.delegate.stopScreencast();
+  }
+  onScreencastFrame(frame, ack) {
+    const asyncResults = [];
+    for (const client of this._clients) {
+      const result = client.onFrame(frame);
+      if (result)
+        asyncResults.push(result);
+    }
+    if (ack) {
+      if (!asyncResults.length)
+        ack();
+      else
+        Promise.race(asyncResults).then(ack);
+    }
+  }
+  async onBeforeCall(sdkObject, metadata, parentId) {
+    if (!this._actions)
+      return;
+    metadata.annotate = true;
+  }
+  async onBeforeInputAction(sdkObject, metadata) {
+    if (!this._actions)
+      return;
+    const page = sdkObject.attribution.page;
+    if (!page)
+      return;
+    const actionTitle = (0, import_utils.renderTitleForCall)(metadata);
+    const utility = await page.mainFrame()._utilityContext();
+    await utility.evaluate(async (options) => {
+      const { injected, duration } = options;
+      injected.setScreencastAnnotation(options);
+      await new Promise((f) => injected.utils.builtins.setTimeout(f, duration));
+      injected.setScreencastAnnotation(null);
+    }, {
+      injected: await utility.injectedScript(),
+      duration: this._actions?.duration ?? 500,
+      point: metadata.point,
+      box: metadata.box,
+      actionTitle,
+      position: this._actions?.position,
+      fontSize: this._actions?.fontSize
+    }).catch((e) => import_utils2.debugLogger.log("error", e));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Screencast
+});

package/lib/server/trace/recorder/snapshotter.js

@@ -57,7 +57,7 @@ class Snapshotter {
   async resetForReuse() {
     if (this._initScript) {
       import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-      await this._context.removeInitScripts([this._initScript]);
+      await this._initScript.dispose();
       this._initScript = void 0;
     }
   }
@@ -69,7 +69,7 @@ class Snapshotter {
     ];
     const { javaScriptEnabled } = this._context._options;
     const initScriptSource = `(${import_snapshotterInjected.frameSnapshotStreamer})("${this._snapshotStreamer}", ${javaScriptEnabled || javaScriptEnabled === void 0})`;
-    this._initScript = await this._context.addInitScript(void 0, initScriptSource);
+    this._initScript = await this._context.addInitScript(initScriptSource);
     await this._context.safeNonStallingEvaluateInAllFrames(initScriptSource, "main");
   }
   dispose() {

package/lib/server/trace/recorder/snapshotterInjected.js

@@ -61,6 +61,7 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
     constructor() {
       this._lastSnapshotNumber = 0;
       this._staleStyleSheets = /* @__PURE__ */ new Set();
+      this._modifiedStyleSheets = /* @__PURE__ */ new Set();
       this._readingStyleSheet = false;
       const invalidateCSSGroupingRule = (rule) => {
         if (rule.parentStyleSheet)
@@ -76,6 +77,10 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       this._interceptNativeMethod(window.CSSGroupingRule.prototype, "insertRule", invalidateCSSGroupingRule);
       this._interceptNativeMethod(window.CSSGroupingRule.prototype, "deleteRule", invalidateCSSGroupingRule);
       this._interceptNativeGetter(window.CSSGroupingRule.prototype, "cssRules", invalidateCSSGroupingRule);
+      this._interceptNativeSetter(window.StyleSheet.prototype, "disabled", (sheet) => {
+        if (sheet instanceof CSSStyleSheet)
+          this._invalidateStyleSheet(sheet);
+      });
       this._interceptNativeAsyncMethod(window.CSSStyleSheet.prototype, "replace", (sheet) => this._invalidateStyleSheet(sheet));
       this._fakeBase = document.createElement("base");
       this._observer = new MutationObserver((list) => this._handleMutations(list));
@@ -148,6 +153,17 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
         }
       });
     }
+    _interceptNativeSetter(obj, prop, cb) {
+      const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+      Object.defineProperty(obj, prop, {
+        ...descriptor,
+        set: function(value) {
+          const result = descriptor.set.call(this, value);
+          cb(this, value);
+          return result;
+        }
+      });
+    }
     _handleMutations(list) {
       for (const mutation of list)
         ensureCachedData(mutation.target).attributesCached = void 0;
@@ -156,6 +172,8 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
       if (this._readingStyleSheet)
         return;
       this._staleStyleSheets.add(sheet);
+      if (sheet.href !== null)
+        this._modifiedStyleSheets.add(sheet);
     }
     _updateStyleElementStyleSheetTextIfNeeded(sheet, forceText) {
       const data = ensureCachedData(sheet);
@@ -248,6 +266,8 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
     _getSheetText(sheet) {
       this._readingStyleSheet = true;
       try {
+        if (sheet.disabled)
+          return "";
         const rules = [];
         for (const rule of sheet.cssRules)
           rules.push(rule.cssText);
@@ -518,7 +538,7 @@ function frameSnapshotStreamer(snapshotStreamer, removeNoScript) {
         wallTime: Date.now(),
         collectionTime: 0
       };
-      for (const sheet of this._staleStyleSheets) {
+      for (const sheet of this._modifiedStyleSheets) {
         if (sheet.href === null)
           continue;
         const content = this._updateLinkStyleSheetTextIfNeeded(sheet, snapshotNumber);

package/lib/server/trace/recorder/tracing.js

@@ -38,6 +38,7 @@ var import_snapshotter = require("./snapshotter");
 var import_protocolMetainfo = require("../../../utils/isomorphic/protocolMetainfo");
 var import_assert = require("../../../utils/isomorphic/assert");
 var import_time = require("../../../utils/isomorphic/time");
+var import_manualPromise = require("../../../utils/isomorphic/manualPromise");
 var import_eventsHelper = require("../../utils/eventsHelper");
 var import_crypto = require("../../utils/crypto");
 var import_userAgent = require("../../utils/userAgent");
@@ -48,15 +49,14 @@ var import_errors = require("../../errors");
 var import_fileUtils = require("../../utils/fileUtils");
 var import_harTracer = require("../../har/harTracer");
 var import_instrumentation = require("../../instrumentation");
-var import_page = require("../../page");
 var import_progress = require("../../progress");
 const version = 8;
-const kScreencastOptions = { width: 800, height: 600, quality: 90 };
 class Tracing extends import_instrumentation.SdkObject {
   constructor(context, tracesDir) {
     super(context, "tracing");
     this._fs = new import_fileUtils.SerializedFS();
     this._screencastListeners = [];
+    this._pageTracingRecorders = /* @__PURE__ */ new Map();
     this._eventListeners = [];
     this._isStopping = false;
     this._allResources = /* @__PURE__ */ new Set();
@@ -219,10 +219,9 @@ class Tracing extends import_instrumentation.SdkObject {
   }
   _stopScreencast() {
     import_eventsHelper.eventsHelper.removeEventListeners(this._screencastListeners);
-    if (!(this._context instanceof import_browserContext.BrowserContext))
-      return;
-    for (const page of this._context.pages())
-      page.setScreencastOptions(null);
+    for (const recorder of this._pageTracingRecorders.values())
+      recorder.dispose();
+    this._pageTracingRecorders.clear();
   }
   _allocateNewTraceFile(state) {
     const suffix = state.chunkOrdinal ? `-chunk${state.chunkOrdinal}` : ``;
@@ -326,23 +325,33 @@ class Tracing extends import_instrumentation.SdkObject {
     return { artifact };
   }
   async _captureSnapshot(snapshotName, sdkObject, metadata) {
-    if (!this._snapshotter)
-      return;
-    if (!sdkObject.attribution.page)
-      return;
-    if (!this._snapshotter.started())
-      return;
-    if (!shouldCaptureSnapshot(metadata))
+    if (!snapshotName || !sdkObject.attribution.page)
       return;
-    await this._snapshotter.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {
+    await this._snapshotter?.captureSnapshot(sdkObject.attribution.page, metadata.id, snapshotName).catch(() => {
     });
   }
-  onBeforeCall(sdkObject, metadata) {
-    const event = createBeforeActionTraceEvent(metadata, this._currentGroupId());
+  _shouldCaptureSnapshot(sdkObject, metadata, phase) {
+    if (!sdkObject.attribution.page || !this._snapshotter?.started())
+      return;
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    if (!metainfo?.snapshot)
+      return false;
+    switch (phase) {
+      case "before":
+        return !metainfo.input || !!metainfo.isAutoWaiting;
+      case "input":
+        return !!metainfo.input;
+      case "after":
+        return true;
+    }
+  }
+  onBeforeCall(sdkObject, metadata, parentId) {
+    const event = createBeforeActionTraceEvent(metadata, parentId ?? this._currentGroupId());
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.beforeSnapshot = `before@${metadata.id}`;
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "before"))
+      event.beforeSnapshot = `before@${metadata.id}`;
     this._state?.callIds.add(metadata.id);
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.beforeSnapshot, sdkObject, metadata);
@@ -353,8 +362,9 @@ class Tracing extends import_instrumentation.SdkObject {
     const event = createInputActionTraceEvent(metadata);
     if (!event)
       return Promise.resolve();
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.inputSnapshot = `input@${metadata.id}`;
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "input"))
+      event.inputSnapshot = `input@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.inputSnapshot, sdkObject, metadata);
   }
@@ -369,15 +379,16 @@ class Tracing extends import_instrumentation.SdkObject {
     if (event)
       this._appendTraceEvent(event);
   }
-  async onAfterCall(sdkObject, metadata) {
+  onAfterCall(sdkObject, metadata) {
     if (!this._state?.callIds.has(metadata.id))
-      return;
+      return Promise.resolve();
     this._state?.callIds.delete(metadata.id);
     const event = createAfterActionTraceEvent(metadata);
     if (!event)
-      return;
-    sdkObject.attribution.page?.temporarilyDisableTracingScreencastThrottling();
-    event.afterSnapshot = `after@${metadata.id}`;
+      return Promise.resolve();
+    this._temporarilyDisableThrottling(sdkObject.attribution.page);
+    if (this._shouldCaptureSnapshot(sdkObject, metadata, "after"))
+      event.afterSnapshot = `after@${metadata.id}`;
     this._appendTraceEvent(event);
     return this._captureSnapshot(event.afterSnapshot, sdkObject, metadata);
   }
@@ -483,26 +494,28 @@ class Tracing extends import_instrumentation.SdkObject {
     };
     this._appendTraceEvent(event);
   }
+  _temporarilyDisableThrottling(page) {
+    if (page)
+      this._pageTracingRecorders.get(page)?.temporarilyDisableThrottling();
+  }
   _startScreencastInPage(page) {
-    page.setScreencastOptions(kScreencastOptions);
     const prefix = page.guid;
-    this._screencastListeners.push(
-      import_eventsHelper.eventsHelper.addEventListener(page, import_page.Page.Events.ScreencastFrame, (params) => {
-        const suffix = params.timestamp || Date.now();
-        const sha1 = `${prefix}-${suffix}.jpeg`;
-        const event = {
-          type: "screencast-frame",
-          pageId: page.guid,
-          sha1,
-          width: params.width,
-          height: params.height,
-          timestamp: (0, import_time.monotonicTime)(),
-          frameSwapWallTime: params.frameSwapWallTime
-        };
-        this._appendResource(sha1, params.buffer);
-        this._appendTraceEvent(event);
-      })
-    );
+    const onFrame = (params) => {
+      const suffix = Date.now();
+      const sha1 = `${prefix}-${suffix}.jpeg`;
+      const event = {
+        type: "screencast-frame",
+        pageId: page.guid,
+        sha1,
+        width: params.viewportWidth,
+        height: params.viewportHeight,
+        timestamp: (0, import_time.monotonicTime)(),
+        frameSwapWallTime: params.frameSwapWallTime
+      };
+      this._appendResource(sha1, params.buffer);
+      this._appendTraceEvent(event);
+    };
+    this._pageTracingRecorders.set(page, new ScreencastTracingRecorder(page.screencast, onFrame));
   }
   _appendTraceEvent(event) {
     const visited = visitTraceEvent(event, this._state.traceSha1s);
@@ -545,10 +558,6 @@ function visitTraceEvent(object, sha1s) {
   }
   return object;
 }
-function shouldCaptureSnapshot(metadata) {
-  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
-  return !!metainfo?.snapshot;
-}
 function createBeforeActionTraceEvent(metadata, parentId) {
   if (metadata.internal || metadata.method.startsWith("tracing"))
     return null;
@@ -598,6 +607,48 @@ function createAfterActionTraceEvent(metadata) {
     point: metadata.point
   };
 }
+const throttledRate = 200;
+const unthrottleDuration = 500;
+class ScreencastTracingRecorder {
+  constructor(screencast, onFrame) {
+    this._unthrottledUntil = 0;
+    this._screencast = screencast;
+    this._client = {
+      onFrame: (frame) => {
+        const time = (0, import_time.monotonicTime)();
+        if (time < this._unthrottledUntil) {
+          onFrame(frame);
+          return;
+        }
+        if (this._pendingAck)
+          return;
+        onFrame(frame);
+        this._pendingAck = new import_manualPromise.ManualPromise();
+        this._timer = setTimeout(() => this._clearPendingAck(), throttledRate);
+        return this._pendingAck;
+      },
+      gracefulClose: () => this.dispose(),
+      dispose: () => this.dispose()
+    };
+    this._screencast.addClient(this._client);
+  }
+  dispose() {
+    this._screencast.removeClient(this._client);
+    this._clearPendingAck();
+  }
+  temporarilyDisableThrottling() {
+    this._unthrottledUntil = (0, import_time.monotonicTime)() + unthrottleDuration;
+    this._clearPendingAck();
+  }
+  _clearPendingAck() {
+    this._pendingAck?.resolve();
+    this._pendingAck = void 0;
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Tracing

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

@@ -47,20 +47,21 @@ var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
 var import_progress = require("../../progress");
 const tracesDirMarker = "traces.dir";
-function validateTraceUrl(traceUrl) {
-  if (!traceUrl)
-    return traceUrl;
-  if (traceUrl.startsWith("http://") || traceUrl.startsWith("https://"))
-    return traceUrl;
-  if (traceUrl.endsWith(".json"))
-    return traceUrl;
+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(traceUrl);
+    const stat = import_fs.default.statSync(traceFile);
     if (stat.isDirectory())
-      return import_path.default.join(traceUrl, tracesDirMarker);
-    return traceUrl;
+      traceFile = import_path.default.join(traceFile, tracesDirMarker);
+    return toFilePathUrl(traceFile);
   } catch {
-    throw new Error(`Trace file ${traceUrl} does not exist!`);
+    throw new Error(`Trace file ${traceFileOrUrl} does not exist!`);
   }
 }
 async function startTraceViewerServer(options) {
@@ -90,7 +91,7 @@ async function startTraceViewerServer(options) {
   });
   const transport = options?.transport || (options?.isServer ? new StdinServer() : void 0);
   if (transport)
-    server.createWebSocket(transport);
+    server.createWebSocket(() => transport);
   const { host, port } = options || {};
   await server.start({ preferredPort: port, host });
   return server;
@@ -125,17 +126,16 @@ async function installRootRedirect(server, traceUrl, options) {
     return true;
   });
 }
-async function runTraceViewerApp(traceUrl, browserName, options, exitOnClose) {
-  traceUrl = validateTraceUrl(traceUrl);
+async function runTraceViewerApp(traceUrl, browserName, options) {
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(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));
+  page.on("close", () => (0, import_utils.gracefullyProcessExitDoNotHang)(0));
   return page;
 }
 async function runTraceInBrowser(traceUrl, options) {
-  traceUrl = validateTraceUrl(traceUrl);
+  traceUrl = validateTraceUrlOrPath(traceUrl);
   const server = await startTraceViewerServer(options);
   await installRootRedirect(server, traceUrl, options);
   await openTraceInBrowser(server.urlPrefix("human-readable"));
@@ -177,8 +177,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);
@@ -221,15 +221,18 @@ function traceDescriptor(traceDir, tracePrefix) {
   };
   for (const name of import_fs.default.readdirSync(traceDir)) {
     if (!tracePrefix || name.startsWith(tracePrefix))
-      result.entries.push({ name, path: import_path.default.join(traceDir, name) });
+      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/usKeyboardLayout.js

@@ -119,6 +119,13 @@ const USKeyboardLayout = {
   "ArrowUp": { "keyCode": 38, "key": "ArrowUp" },
   "ArrowRight": { "keyCode": 39, "key": "ArrowRight" },
   "ArrowDown": { "keyCode": 40, "key": "ArrowDown" },
+  // Media keys
+  "AudioVolumeMute": { "keyCode": 173, "key": "AudioVolumeMute" },
+  "AudioVolumeDown": { "keyCode": 174, "key": "AudioVolumeDown" },
+  "AudioVolumeUp": { "keyCode": 175, "key": "AudioVolumeUp" },
+  "MediaTrackNext": { "keyCode": 176, "key": "MediaTrackNext" },
+  "MediaTrackPrevious": { "keyCode": 177, "key": "MediaTrackPrevious" },
+  "MediaPlayPause": { "keyCode": 179, "key": "MediaPlayPause" },
   // Numpad
   "NumLock": { "keyCode": 144, "key": "NumLock" },
   "NumpadDivide": { "keyCode": 111, "key": "/", "location": 3 },

package/lib/server/utils/comparators.js

@@ -37,7 +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");
+var import_imageUtils = require("../../utils/isomorphic/imageUtils");
 function getComparator(mimeType) {
   if (mimeType === "image/png")
     return compareImages.bind(null, "image/png");

package/lib/server/utils/disposable.js

@@ -0,0 +1,32 @@
+"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 disposable_exports = {};
+__export(disposable_exports, {
+  disposeAll: () => disposeAll
+});
+module.exports = __toCommonJS(disposable_exports);
+async function disposeAll(disposables) {
+  const copy = [...disposables];
+  disposables.length = 0;
+  await Promise.all(copy.map((d) => d.dispose()));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  disposeAll
+});

package/lib/server/utils/eventsHelper.js

@@ -24,7 +24,9 @@ module.exports = __toCommonJS(eventsHelper_exports);
 class EventsHelper {
   static addEventListener(emitter, eventName, handler) {
     emitter.on(eventName, handler);
-    return { emitter, eventName, handler };
+    return { emitter, eventName, handler, dispose: async () => {
+      emitter.removeListener(eventName, handler);
+    } };
   }
   static removeEventListeners(listeners) {
     for (const listener of listeners)