patchright-core 1.57.0 → 1.59.0

package/lib/server/har/harRecorder.js

@@ -37,7 +37,6 @@ var import_artifact = require("../artifact");
 var import_harTracer = require("./harTracer");
 var import_crypto = require("../utils/crypto");
 var import_manualPromise = require("../../utils/isomorphic/manualPromise");
-var import_zipBundle = require("../../zipBundle");
 class HarRecorder {
   constructor(context, page, options) {
     this._isFlushed = false;
@@ -56,7 +55,8 @@ class HarRecorder {
       waitForContentOnStop: true,
       urlFilter: urlFilterRe ?? options.urlGlob
     });
-    this._zipFile = content === "attach" || expectsZip ? new import_zipBundle.yazl.ZipFile() : null;
+    const { yazl } = require("../../zipBundle");
+    this._zipFile = content === "attach" || expectsZip ? new yazl.ZipFile() : null;
     this._tracer.start({ omitScripts: false });
   }
   onEntryStarted(entry) {

package/lib/server/har/harTracer.js

@@ -278,9 +278,6 @@ class HarTracer {
           harEntry._securityDetails = details;
       }));
     }
-    const httpVersion = response.httpVersion();
-    harEntry.request.httpVersion = httpVersion;
-    harEntry.response.httpVersion = httpVersion;
     const compressionCalculationBarrier = this._options.omitSizes ? void 0 : {
       _encodedBodySize: -1,
       _decodedBodySize: -1,
@@ -317,6 +314,10 @@ class HarTracer {
         this._delegate.onEntryFinished(harEntry);
     });
     this._addBarrier(page || request.serviceWorker(), promise);
+    this._addBarrier(page || request.serviceWorker(), response.httpVersion().then((httpVersion) => {
+      harEntry.request.httpVersion = httpVersion;
+      harEntry.response.httpVersion = httpVersion;
+    }));
     const timing = response.timing();
     harEntry.timings.receive = response.request()._responseEndTiming !== -1 ? import_helper.helper.millisToRoundishMillis(response.request()._responseEndTiming - timing.responseStart) : -1;
     this._computeHarEntryTotalTime(harEntry);
@@ -389,7 +390,7 @@ class HarTracer {
     harEntry.response = {
       status: response.status(),
       statusText: response.statusText(),
-      httpVersion: response.httpVersion(),
+      httpVersion: FALLBACK_HTTP_VERSION,
       // These are bad values that will be overwritten below.
       cookies: [],
       headers: [],

package/lib/server/input.js

@@ -48,6 +48,10 @@ class Keyboard {
     this._raw = raw;
     this._page = page;
   }
+  async apiDown(progress, key) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.down(progress, key);
+  }
   async down(progress, key) {
     const description = this._keyDescriptionForString(key);
     const autoRepeat = this._pressedKeys.has(description.code);
@@ -67,6 +71,10 @@ class Keyboard {
       return { ...description, text: "" };
     return description;
   }
+  async apiUp(progress, key) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.up(progress, key);
+  }
   async up(progress, key) {
     const description = this._keyDescriptionForString(key);
     if (kModifiers.includes(description.key))
@@ -74,9 +82,17 @@ class Keyboard {
     this._pressedKeys.delete(description.code);
     await this._raw.keyup(progress, this._pressedModifiers, key, description);
   }
-  async insertText(progress, text) {
+  async apiInsertText(progress, text) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this._insertText(progress, text);
+  }
+  async _insertText(progress, text) {
     await this._raw.sendText(progress, text);
   }
+  async apiType(progress, text, options) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.type(progress, text, options);
+  }
   async type(progress, text, options) {
     const delay = options && options.delay || void 0;
     for (const char of text) {
@@ -85,10 +101,14 @@ class Keyboard {
       } else {
         if (delay)
           await progress.wait(delay);
-        await this.insertText(progress, char);
+        await this._insertText(progress, char);
       }
     }
   }
+  async apiPress(progress, key, options = {}) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.press(progress, key, options);
+  }
   async press(progress, key, options = {}) {
     function split(keyString) {
       const keys = [];
@@ -157,6 +177,11 @@ class Mouse {
   currentPoint() {
     return { x: this._x, y: this._y };
   }
+  async apiMove(progress, x, y, options = {}) {
+    progress.metadata.point = { x, y };
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.move(progress, x, y, options);
+  }
   async move(progress, x, y, options = {}) {
     const { steps = 1 } = options;
     const fromX = this._x;
@@ -169,18 +194,33 @@ class Mouse {
       await this._raw.move(progress, middleX, middleY, this._lastButton, this._buttons, this._keyboard._modifiers(), !!options.forClick);
     }
   }
+  async apiDown(progress, options = {}) {
+    progress.metadata.point = this.currentPoint();
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.down(progress, options);
+  }
   async down(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = button;
     this._buttons.add(button);
     await this._raw.down(progress, this._x, this._y, this._lastButton, this._buttons, this._keyboard._modifiers(), clickCount);
   }
+  async apiUp(progress, options = {}) {
+    progress.metadata.point = this.currentPoint();
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.up(progress, options);
+  }
   async up(progress, options = {}) {
     const { button = "left", clickCount = 1 } = options;
     this._lastButton = "none";
     this._buttons.delete(button);
     await this._raw.up(progress, this._x, this._y, button, this._buttons, this._keyboard._modifiers(), clickCount);
   }
+  async apiClick(progress, x, y, options = {}) {
+    progress.metadata.point = { x, y };
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.click(progress, x, y, options);
+  }
   async click(progress, x, y, options = {}) {
     const { delay = null, clickCount = 1, steps } = options;
     if (delay) {
@@ -206,7 +246,8 @@ class Mouse {
       await Promise.all(promises);
     }
   }
-  async wheel(progress, deltaX, deltaY) {
+  async apiWheel(progress, deltaX, deltaY) {
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
     await this._raw.wheel(progress, this._x, this._y, this._buttons, this._keyboard._modifiers(), deltaX, deltaY);
   }
 }
@@ -260,9 +301,13 @@ class Touchscreen {
     this._raw = raw;
     this._page = page;
   }
-  async tap(progress, x, y) {
+  async apiTap(progress, x, y) {
     if (!this._page.browserContext._options.hasTouch)
       throw new Error("hasTouch must be enabled on the browser context before using the touchscreen.");
+    await this._page.instrumentation.onBeforeInputAction(this._page, progress.metadata);
+    await this.tap(progress, x, y);
+  }
+  async tap(progress, x, y) {
     await this._raw.tap(progress, x, y, this._page.keyboard._modifiers());
   }
 }

package/lib/server/instrumentation.js

@@ -25,6 +25,7 @@ __export(instrumentation_exports, {
 module.exports = __toCommonJS(instrumentation_exports);
 var import_events = require("events");
 var import_crypto = require("./utils/crypto");
+var import_debugLogger = require("./utils/debugLogger");
 class SdkObject extends import_events.EventEmitter {
   constructor(parent, guidPrefix, guid) {
     super();
@@ -33,6 +34,13 @@ class SdkObject extends import_events.EventEmitter {
     this.attribution = { ...parent.attribution };
     this.instrumentation = parent.instrumentation;
   }
+  apiLog(message) {
+    if (!this.attribution.playwright.options.isInternalPlaywright)
+      import_debugLogger.debugLogger.log("api", message);
+  }
+  closeReason() {
+    return this.attribution.page?._closeReason || this.attribution.context?._closeReason || this.attribution.browser?._closeReason;
+  }
 }
 function createRootSdkObject() {
   const fakeParent = { attribution: {}, instrumentation: createInstrumentation() };

package/lib/server/javascript.js

@@ -113,30 +113,14 @@ class JSHandle extends import_instrumentation.SdkObject {
   async evaluateHandle(pageFunction, arg) {
     return evaluate(this._context, false, pageFunction, this, arg);
   }
-  async evaluateExpression(expression, options, arg, isolatedContext) {
-    let context = this._context;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    const value = await evaluateExpression(context, expression, { ...options, returnByValue: true }, this, arg);
-    await context.doSlowMo();
+  async evaluateExpression(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: true }, this, arg);
+    await this._context.doSlowMo();
     return value;
   }
-  async evaluateExpressionHandle(expression, options, arg, isolatedContext) {
-    let context = this._context;
-    if (context.constructor.name === "FrameExecutionContext") {
-      const frame = this._context.frame;
-      if (frame) {
-        if (isolatedContext) context = await frame._utilityContext();
-        else if (!isolatedContext) context = await frame._mainContext();
-      }
-    }
-    const value = await evaluateExpression(context, expression, { ...options, returnByValue: false }, this, arg);
-    await context.doSlowMo();
+  async evaluateExpressionHandle(expression, options, arg) {
+    const value = await evaluateExpression(this._context, expression, { ...options, returnByValue: false }, this, arg);
+    await this._context.doSlowMo();
     return value;
   }
   async getProperty(propertyName) {

package/lib/server/launchApp.js

@@ -106,7 +106,6 @@ async function syncLocalStorageWithSettings(page, appName) {
     });
     const settings = await import_fs.default.promises.readFile(settingsFile, "utf-8").catch(() => "{}");
     await page.addInitScript(
-      progress,
       `(${String((settings2) => {
         if (location && location.protocol === "data:")
           return;

package/lib/server/localUtils.js

@@ -45,13 +45,13 @@ var import_crypto = require("./utils/crypto");
 var import_harBackend = require("./harBackend");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_zipFile = require("./utils/zipFile");
-var import_zipBundle = require("../zipBundle");
-var import_traceUtils = require("../utils/isomorphic/traceUtils");
+var import_traceUtils = require("../utils/isomorphic/trace/traceUtils");
 var import_assert = require("../utils/isomorphic/assert");
 var import_fileUtils = require("./utils/fileUtils");
 async function zip(progress, stackSessions, params) {
   const promise = new import_manualPromise.ManualPromise();
-  const zipFile = new import_zipBundle.yazl.ZipFile();
+  const { yauzl, yazl } = require("../zipBundle");
+  const zipFile = new yazl.ZipFile();
   zipFile.on("error", (error) => promise.reject(error));
   const addFile = (file, name) => {
     try {
@@ -69,7 +69,7 @@ async function zip(progress, stackSessions, params) {
     zipFile.addBuffer(buffer, "trace.stacks");
   }
   if (params.includeSources) {
-    const sourceFiles = /* @__PURE__ */ new Set();
+    const sourceFiles = new Set(params.additionalSources);
     for (const { stack } of stackSession?.callStacks || []) {
       if (!stack)
         continue;
@@ -77,7 +77,7 @@ async function zip(progress, stackSessions, params) {
         sourceFiles.add(file);
     }
     for (const sourceFile of sourceFiles)
-      addFile(sourceFile, "resources/src@" + await (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
+      addFile(sourceFile, "resources/src@" + (0, import_crypto.calculateSha1)(sourceFile) + ".txt");
   }
   if (params.mode === "write") {
     await progress.race(import_fs.default.promises.mkdir(import_path.default.dirname(params.zipFile), { recursive: true }));
@@ -90,7 +90,7 @@ async function zip(progress, stackSessions, params) {
   }
   const tempFile = params.zipFile + ".tmp";
   await progress.race(import_fs.default.promises.rename(params.zipFile, tempFile));
-  import_zipBundle.yauzl.open(tempFile, (err, inZipFile) => {
+  yauzl.open(tempFile, (err, inZipFile) => {
     if (err) {
       promise.reject(err);
       return;

package/lib/server/network.js

@@ -22,6 +22,7 @@ __export(network_exports, {
   Response: () => Response,
   Route: () => Route,
   WebSocket: () => WebSocket,
+  applyHeadersOverrides: () => applyHeadersOverrides,
   filterCookies: () => filterCookies,
   isLocalHostname: () => isLocalHostname,
   kMaxCookieExpiresDateInSeconds: () => kMaxCookieExpiresDateInSeconds,
@@ -61,6 +62,48 @@ function filterCookies(cookies, urls) {
 function isLocalHostname(hostname) {
   return hostname === "localhost" || hostname.endsWith(".localhost");
 }
+const FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "set-cookie",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+const FORBIDDEN_METHODS = /* @__PURE__ */ new Set(["CONNECT", "TRACE", "TRACK"]);
+function isForbiddenHeader(name, value) {
+  const lowerName = name.toLowerCase();
+  if (FORBIDDEN_HEADER_NAMES.has(lowerName))
+    return true;
+  if (lowerName.startsWith("proxy-"))
+    return true;
+  if (lowerName.startsWith("sec-"))
+    return true;
+  if (lowerName === "x-http-method" || lowerName === "x-http-method-override" || lowerName === "x-method-override") {
+    if (value && FORBIDDEN_METHODS.has(value.toUpperCase()))
+      return true;
+  }
+  return false;
+}
+function applyHeadersOverrides(original, overrides) {
+  const forbiddenHeaders = original.filter((header) => isForbiddenHeader(header.name, header.value));
+  const allowedHeaders = overrides.filter((header) => !isForbiddenHeader(header.name, header.value));
+  return mergeHeaders([allowedHeaders, forbiddenHeaders]);
+}
 const kMaxCookieExpiresDateInSeconds = 253402300799;
 function rewriteCookies(cookies) {
   return cookies.map((c) => {
@@ -99,7 +142,6 @@ class Request extends import_instrumentation.SdkObject {
     this._response = null;
     this._redirectedTo = null;
     this._failureText = null;
-    this._headersMap = /* @__PURE__ */ new Map();
     this._frame = null;
     this._serviceWorker = null;
     this._rawRequestHeadersPromise = new import_manualPromise.ManualPromise();
@@ -118,7 +160,6 @@ class Request extends import_instrumentation.SdkObject {
     this._method = method;
     this._postData = postData;
     this._headers = headers;
-    this._updateHeadersMap();
     this._isFavicon = url.endsWith("/favicon.ico") || !!redirectedFrom?._isFavicon;
   }
   static {
@@ -132,13 +173,8 @@ class Request extends import_instrumentation.SdkObject {
   }
   _applyOverrides(overrides) {
     this._overrides = { ...this._overrides, ...overrides };
-    this._updateHeadersMap();
     return this._overrides;
   }
-  _updateHeadersMap() {
-    for (const { name, value } of this.headers())
-      this._headersMap.set(name.toLowerCase(), value);
-  }
   overrides() {
     return this._overrides;
   }
@@ -158,7 +194,8 @@ class Request extends import_instrumentation.SdkObject {
     return this._overrides?.headers || this._headers;
   }
   headerValue(name) {
-    return this._headersMap.get(name);
+    const lowerCaseName = name.toLowerCase();
+    return this.headers().find((h) => h.name.toLowerCase() === lowerCaseName)?.value;
   }
   // "null" means no raw headers available - we'll use provisional headers as raw headers.
   setRawRequestHeaders(headers) {
@@ -309,10 +346,7 @@ class Route extends import_instrumentation.SdkObject {
         throw new Error("New URL must have same protocol as overridden URL");
     }
     if (overrides.headers) {
-      overrides.headers = overrides.headers?.filter((header) => {
-        const headerName = header.name.toLowerCase();
-        return headerName !== "cookie" && headerName !== "host";
-      });
+      overrides.headers = applyHeadersOverrides(this._request._headers, overrides.headers);
     }
     overrides = this._request._applyOverrides(overrides);
     const nextHandler = this._futureHandlers.shift();
@@ -339,7 +373,7 @@ class Route extends import_instrumentation.SdkObject {
   }
 }
 class Response extends import_instrumentation.SdkObject {
-  constructor(request, status, statusText2, headers, timing, getResponseBodyCallback, fromServiceWorker, httpVersion) {
+  constructor(request, status, statusText2, headers, timing, getResponseBodyCallback, fromServiceWorker) {
     super(request.frame() || request._context, "response");
     this._contentPromise = null;
     this._finishedPromise = new import_manualPromise.ManualPromise();
@@ -347,6 +381,7 @@ class Response extends import_instrumentation.SdkObject {
     this._serverAddrPromise = new import_manualPromise.ManualPromise();
     this._securityDetailsPromise = new import_manualPromise.ManualPromise();
     this._rawResponseHeadersPromise = new import_manualPromise.ManualPromise();
+    this._httpVersionPromise = new import_manualPromise.ManualPromise();
     this._encodedBodySizePromise = new import_manualPromise.ManualPromise();
     this._transferSizePromise = new import_manualPromise.ManualPromise();
     this._responseHeadersSizePromise = new import_manualPromise.ManualPromise();
@@ -360,7 +395,6 @@ class Response extends import_instrumentation.SdkObject {
       this._headersMap.set(name.toLowerCase(), value);
     this._getResponseBodyCallback = getResponseBodyCallback;
     this._request._setResponse(this);
-    this._httpVersion = httpVersion;
     this._fromServiceWorker = fromServiceWorker;
   }
   _serverAddrFinished(addr) {
@@ -376,7 +410,7 @@ class Response extends import_instrumentation.SdkObject {
     this._finishedPromise.resolve();
   }
   _setHttpVersion(httpVersion) {
-    this._httpVersion = httpVersion;
+    this._httpVersionPromise.resolve(httpVersion);
   }
   url() {
     return this._url;
@@ -436,17 +470,21 @@ class Response extends import_instrumentation.SdkObject {
   request() {
     return this._request;
   }
+  finished() {
+    return this._finishedPromise;
+  }
   frame() {
     return this._request.frame();
   }
-  httpVersion() {
-    if (!this._httpVersion)
+  async httpVersion() {
+    const httpVersion = await this._httpVersionPromise || null;
+    if (!httpVersion)
       return "HTTP/1.1";
-    if (this._httpVersion === "http/1.1")
+    if (httpVersion === "http/1.1")
       return "HTTP/1.1";
-    if (this._httpVersion === "h2")
+    if (httpVersion === "h2")
       return "HTTP/2.0";
-    return this._httpVersion;
+    return httpVersion;
   }
   fromServiceWorker() {
     return this._fromServiceWorker;
@@ -617,6 +655,7 @@ function mergeHeaders(headers) {
   Response,
   Route,
   WebSocket,
+  applyHeadersOverrides,
   filterCookies,
   isLocalHostname,
   kMaxCookieExpiresDateInSeconds,

package/lib/server/overlay.js

@@ -0,0 +1,138 @@
+"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 overlay_exports = {};
+__export(overlay_exports, {
+  Overlay: () => Overlay
+});
+module.exports = __toCommonJS(overlay_exports);
+var import_utils = require("../utils");
+var import_page = require("./page");
+class Overlay {
+  constructor(page) {
+    this._overlays = /* @__PURE__ */ new Map();
+    this._page = page;
+    this._page.on(import_page.Page.Events.InternalFrameNavigatedToNewDocument, (frame) => {
+      if (frame.parentFrame())
+        return;
+      for (const [id, html] of this._overlays)
+        this._doAdd(id, html).catch((e) => import_utils.debugLogger.log("error", e));
+    });
+  }
+  dispose() {
+  }
+  async show(html, duration) {
+    const id = (0, import_utils.createGuid)();
+    this._overlays.set(id, html);
+    await this._doAdd(id, html).catch((e) => import_utils.debugLogger.log("error", e));
+    if (duration) {
+      await new Promise((f) => setTimeout(f, duration));
+      await this.remove(id);
+    }
+    return id;
+  }
+  async _doAdd(id, html) {
+    const utility = await this._page.mainFrame()._utilityContext();
+    await utility.evaluate(({ injected, html: html2, id: id2 }) => {
+      return injected.addUserOverlay(id2, html2);
+    }, { injected: await utility.injectedScript(), html, id });
+  }
+  async remove(id) {
+    this._overlays.delete(id);
+    const utility = await this._page.mainFrame()._utilityContext();
+    await utility.evaluate(({ injected, id: id2 }) => {
+      injected.removeUserOverlay(id2);
+    }, { injected: await utility.injectedScript(), id }).catch((e) => import_utils.debugLogger.log("error", e));
+  }
+  async chapter(options) {
+    const fadeDuration = 300;
+    const descriptionHtml = options.description ? `<div id="description">${(0, import_utils.escapeHTML)(options.description)}</div>` : "";
+    const styleSheet = `
+      @keyframes pw-chapter-fade-in {
+        from { opacity: 0; }
+        to { opacity: 1; }
+      }
+      @keyframes pw-chapter-fade-out {
+        from { opacity: 1; }
+        to { opacity: 0; }
+      }
+      #background {
+        position: absolute;
+        inset: 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        backdrop-filter: blur(2px);
+        animation: pw-chapter-fade-in ${fadeDuration}ms ease-out forwards;
+      }
+      #background.fade-out {
+        animation: pw-chapter-fade-out ${fadeDuration}ms ease-in forwards;
+      }
+      #content {
+        background: rgba(0, 0, 0, 0.7);
+        border: 1px solid rgba(255, 255, 255, 0.15);
+        border-radius: 16px;
+        padding: 40px 56px;
+        max-width: 560px;
+        box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+      }
+      #title {
+        color: white;
+        font-family: system-ui, -apple-system, sans-serif;
+        font-size: 28px;
+        font-weight: 600;
+        line-height: 1.3;
+        text-align: center;
+        letter-spacing: -0.01em;
+      }
+      #description {
+        color: rgba(255, 255, 255, 0.7);
+        font-family: system-ui, -apple-system, sans-serif;
+        font-size: 15px;
+        line-height: 1.5;
+        margin-top: 12px;
+        text-align: center;
+      }
+    `;
+    const duration = options.duration ?? 2e3;
+    const html = `<style>${styleSheet}</style><div id="background"><div id="content"><div id="title">${(0, import_utils.escapeHTML)(options.title)}</div>${descriptionHtml}</div></div>`;
+    const id = await this.show(html);
+    await new Promise((f) => setTimeout(f, duration));
+    const utility = await this._page.mainFrame()._utilityContext();
+    await utility.evaluate(({ injected, id: id2, fadeDuration: fadeDuration2 }) => {
+      const overlay = injected.getUserOverlay(id2);
+      const bg = overlay?.querySelector("#background");
+      if (bg)
+        bg.classList.add("fade-out");
+      return new Promise((f) => injected.utils.builtins.setTimeout(f, fadeDuration2));
+    }, { injected: await utility.injectedScript(), id, fadeDuration }).catch((e) => import_utils.debugLogger.log("error", e));
+    await this.remove(id);
+  }
+  async setVisible(visible) {
+    if (!this._overlays.size)
+      return;
+    const utility = await this._page.mainFrame()._utilityContext();
+    await utility.evaluate(({ injected, visible: visible2 }) => {
+      injected.setUserOverlaysVisible(visible2);
+    }, { injected: await utility.injectedScript(), visible }).catch((e) => import_utils.debugLogger.log("error", e));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Overlay
+});