chrome-devtools-frontend 1.0.1367881 → 1.0.1376716

package/front_end/third_party/puppeteer/package/src/api/locators/locators.ts

@@ -108,7 +108,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * @public
    */
   static race<Locators extends readonly unknown[] | []>(
-    locators: Locators
+    locators: Locators,
   ): Locator<AwaitedLocator<Locators[number]>> {
     return RaceLocator.create(locators);
   }
@@ -136,19 +136,19 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
   protected operators = {
     conditions: (
       conditions: Array<Action<T, never>>,
-      signal?: AbortSignal
+      signal?: AbortSignal,
     ): OperatorFunction<HandleFor<T>, HandleFor<T>> => {
       return mergeMap((handle: HandleFor<T>) => {
         return merge(
           ...conditions.map(condition => {
             return condition(handle, signal);
-          })
+          }),
         ).pipe(defaultIfEmpty(handle));
       });
     },
     retryAndRaceWithSignalAndTimer: <T>(
       signal?: AbortSignal,
-      cause?: Error
+      cause?: Error,
     ): OperatorFunction<T, T> => {
       const candidates = [];
       if (signal) {
@@ -157,7 +157,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
       candidates.push(timeout(this._timeout, cause));
       return pipe(
         retry({delay: RETRY_DELAY}),
-        raceWith<T, never[]>(...candidates)
+        raceWith<T, never[]>(...candidates),
       );
     },
   };
@@ -187,7 +187,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   setVisibility<NodeType extends Node>(
     this: Locator<NodeType>,
-    visibility: VisibilityOption
+    visibility: VisibilityOption,
   ): Locator<NodeType> {
     const locator = this._clone();
     locator.visibility = visibility;
@@ -203,7 +203,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   setWaitForEnabled<NodeType extends Node>(
     this: Locator<NodeType>,
-    value: boolean
+    value: boolean,
   ): Locator<NodeType> {
     const locator = this._clone();
     locator.#waitForEnabled = value;
@@ -219,7 +219,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   setEnsureElementIsInTheViewport<ElementType extends Element>(
     this: Locator<ElementType>,
-    value: boolean
+    value: boolean,
   ): Locator<ElementType> {
     const locator = this._clone();
     locator.#ensureElementIsInTheViewport = value;
@@ -235,7 +235,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   setWaitForStableBoundingBox<ElementType extends Element>(
     this: Locator<ElementType>,
-    value: boolean
+    value: boolean,
   ): Locator<ElementType> {
     const locator = this._clone();
     locator.#waitForStableBoundingBox = value;
@@ -260,7 +260,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   #waitForEnabledIfNeeded = <ElementType extends Node>(
     handle: HandleFor<ElementType>,
-    signal?: AbortSignal
+    signal?: AbortSignal,
   ): Observable<never> => {
     if (!this.#waitForEnabled) {
       return EMPTY;
@@ -285,8 +285,8 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           timeout: this._timeout,
           signal,
         },
-        handle
-      )
+        handle,
+      ),
     ).pipe(ignoreElements());
   };
 
@@ -295,7 +295,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * frames and waits till they are the same.
    */
   #waitForStableBoundingBoxIfNeeded = <ElementType extends Element>(
-    handle: HandleFor<ElementType>
+    handle: HandleFor<ElementType>,
   ): Observable<never> => {
     if (!this.#waitForStableBoundingBox) {
       return EMPTY;
@@ -326,7 +326,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
               });
             });
           });
-        })
+        }),
       );
     }).pipe(
       first(([rect1, rect2]) => {
@@ -338,7 +338,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
         );
       }),
       retry({delay: RETRY_DELAY}),
-      ignoreElements()
+      ignoreElements(),
     );
   };
 
@@ -346,7 +346,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * Checks if the element is in the viewport and auto-scrolls it if it is not.
    */
   #ensureElementIsInTheViewportIfNeeded = <ElementType extends Element>(
-    handle: HandleFor<ElementType>
+    handle: HandleFor<ElementType>,
   ): Observable<never> => {
     if (!this.#ensureElementIsInTheViewport) {
       return EMPTY;
@@ -362,13 +362,13 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
         return defer(() => {
           return from(handle.isIntersectingViewport({threshold: 0}));
         }).pipe(first(identity), retry({delay: RETRY_DELAY}), ignoreElements());
-      })
+      }),
     );
   };
 
   #click<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<LocatorClickOptions>
+    options?: Readonly<LocatorClickOptions>,
   ): Observable<void> {
     const signal = options?.signal;
     const cause = new Error('Locator.click');
@@ -379,7 +379,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           this.#waitForStableBoundingBoxIfNeeded,
           this.#waitForEnabledIfNeeded,
         ],
-        signal
+        signal,
       ),
       tap(() => {
         return this.emit(LocatorEvent.Action, undefined);
@@ -389,17 +389,17 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           catchError(err => {
             void handle.dispose().catch(debugError);
             throw err;
-          })
+          }),
         );
       }),
-      this.operators.retryAndRaceWithSignalAndTimer(signal, cause)
+      this.operators.retryAndRaceWithSignalAndTimer(signal, cause),
     );
   }
 
   #fill<ElementType extends Element>(
     this: Locator<ElementType>,
     value: string,
-    options?: Readonly<ActionOptions>
+    options?: Readonly<ActionOptions>,
   ): Observable<void> {
     const signal = options?.signal;
     const cause = new Error('Locator.fill');
@@ -410,7 +410,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           this.#waitForStableBoundingBoxIfNeeded,
           this.#waitForEnabledIfNeeded,
         ],
-        signal
+        signal,
       ),
       tap(() => {
         return this.emit(LocatorEvent.Action, undefined);
@@ -448,7 +448,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
             }
 
             return 'unknown';
-          })
+          }),
         )
           .pipe(
             mergeMap(inputType => {
@@ -492,11 +492,11 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
                         input.value = originalValue;
                       }
                       return newValue.substring(originalValue.length);
-                    }, value)
+                    }, value),
                   ).pipe(
                     mergeMap(textToType => {
                       return from(handle.type(textToType));
-                    })
+                    }),
                   );
                 case 'other-input':
                   return from(handle.focus()).pipe(
@@ -505,34 +505,34 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
                         handle.evaluate((input, value) => {
                           (input as HTMLInputElement).value = value;
                           input.dispatchEvent(
-                            new Event('input', {bubbles: true})
+                            new Event('input', {bubbles: true}),
                           );
                           input.dispatchEvent(
-                            new Event('change', {bubbles: true})
+                            new Event('change', {bubbles: true}),
                           );
-                        }, value)
+                        }, value),
                       );
-                    })
+                    }),
                   );
                 case 'unknown':
                   throw new Error(`Element cannot be filled out.`);
               }
-            })
+            }),
           )
           .pipe(
             catchError(err => {
               void handle.dispose().catch(debugError);
               throw err;
-            })
+            }),
           );
       }),
-      this.operators.retryAndRaceWithSignalAndTimer(signal, cause)
+      this.operators.retryAndRaceWithSignalAndTimer(signal, cause),
     );
   }
 
   #hover<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<ActionOptions>
+    options?: Readonly<ActionOptions>,
   ): Observable<void> {
     const signal = options?.signal;
     const cause = new Error('Locator.hover');
@@ -542,7 +542,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           this.#ensureElementIsInTheViewportIfNeeded,
           this.#waitForStableBoundingBoxIfNeeded,
         ],
-        signal
+        signal,
       ),
       tap(() => {
         return this.emit(LocatorEvent.Action, undefined);
@@ -552,16 +552,16 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           catchError(err => {
             void handle.dispose().catch(debugError);
             throw err;
-          })
+          }),
         );
       }),
-      this.operators.retryAndRaceWithSignalAndTimer(signal, cause)
+      this.operators.retryAndRaceWithSignalAndTimer(signal, cause),
     );
   }
 
   #scroll<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<LocatorScrollOptions>
+    options?: Readonly<LocatorScrollOptions>,
   ): Observable<void> {
     const signal = options?.signal;
     const cause = new Error('Locator.scroll');
@@ -571,7 +571,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
           this.#ensureElementIsInTheViewportIfNeeded,
           this.#waitForStableBoundingBoxIfNeeded,
         ],
-        signal
+        signal,
       ),
       tap(() => {
         return this.emit(LocatorEvent.Action, undefined);
@@ -588,16 +588,16 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
               }
             },
             options?.scrollTop,
-            options?.scrollLeft
-          )
+            options?.scrollLeft,
+          ),
         ).pipe(
           catchError(err => {
             void handle.dispose().catch(debugError);
             throw err;
-          })
+          }),
         );
       }),
-      this.operators.retryAndRaceWithSignalAndTimer(signal, cause)
+      this.operators.retryAndRaceWithSignalAndTimer(signal, cause),
     );
   }
 
@@ -627,8 +627,8 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
     const cause = new Error('Locator.waitHandle');
     return await firstValueFrom(
       this._wait(options).pipe(
-        this.operators.retryAndRaceWithSignalAndTimer(options?.signal, cause)
-      )
+        this.operators.retryAndRaceWithSignalAndTimer(options?.signal, cause),
+      ),
     );
   }
 
@@ -668,7 +668,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
       await (handle as ElementHandle<Node>).frame.waitForFunction(
         predicate,
         {signal, timeout: this._timeout},
-        handle
+        handle,
       );
       return true;
     });
@@ -682,7 +682,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    * @internal
    */
   filterHandle<S extends T>(
-    predicate: Predicate<HandleFor<T>, HandleFor<S>>
+    predicate: Predicate<HandleFor<T>, HandleFor<S>>,
   ): Locator<S> {
     return new FilteredLocator(this._clone(), predicate);
   }
@@ -701,7 +701,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   click<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<LocatorClickOptions>
+    options?: Readonly<LocatorClickOptions>,
   ): Promise<void> {
     return firstValueFrom(this.#click(options));
   }
@@ -715,7 +715,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
   fill<ElementType extends Element>(
     this: Locator<ElementType>,
     value: string,
-    options?: Readonly<ActionOptions>
+    options?: Readonly<ActionOptions>,
   ): Promise<void> {
     return firstValueFrom(this.#fill(value, options));
   }
@@ -725,7 +725,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   hover<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<ActionOptions>
+    options?: Readonly<ActionOptions>,
   ): Promise<void> {
     return firstValueFrom(this.#hover(options));
   }
@@ -735,7 +735,7 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
    */
   scroll<ElementType extends Element>(
     this: Locator<ElementType>,
-    options?: Readonly<LocatorScrollOptions>
+    options?: Readonly<LocatorScrollOptions>,
   ): Promise<void> {
     return firstValueFrom(this.#scroll(options));
   }
@@ -747,12 +747,12 @@ export abstract class Locator<T> extends EventEmitter<LocatorEvents> {
 export class FunctionLocator<T> extends Locator<T> {
   static create<Ret>(
     pageOrFrame: Page | Frame,
-    func: () => Awaitable<Ret>
+    func: () => Awaitable<Ret>,
   ): Locator<Ret> {
     return new FunctionLocator<Ret>(pageOrFrame, func).setTimeout(
       'getDefaultTimeout' in pageOrFrame
         ? pageOrFrame.getDefaultTimeout()
-        : pageOrFrame.page().getDefaultTimeout()
+        : pageOrFrame.page().getDefaultTimeout(),
     );
   }
 
@@ -777,7 +777,7 @@ export class FunctionLocator<T> extends Locator<T> {
         this.#pageOrFrame.waitForFunction(this.#func, {
           timeout: this.timeout,
           signal,
-        })
+        }),
       );
     }).pipe(throwIfEmpty());
   }
@@ -821,10 +821,10 @@ export abstract class DelegatedLocator<T, U> extends Locator<U> {
 
   override setVisibility<ValueType extends Node, NodeType extends Node>(
     this: DelegatedLocator<ValueType, NodeType>,
-    visibility: VisibilityOption
+    visibility: VisibilityOption,
   ): DelegatedLocator<ValueType, NodeType> {
     const locator = super.setVisibility<NodeType>(
-      visibility
+      visibility,
     ) as DelegatedLocator<ValueType, NodeType>;
     locator.#delegate = locator.#delegate.setVisibility<ValueType>(visibility);
     return locator;
@@ -832,10 +832,10 @@ export abstract class DelegatedLocator<T, U> extends Locator<U> {
 
   override setWaitForEnabled<ValueType extends Node, NodeType extends Node>(
     this: DelegatedLocator<ValueType, NodeType>,
-    value: boolean
+    value: boolean,
   ): DelegatedLocator<ValueType, NodeType> {
     const locator = super.setWaitForEnabled<NodeType>(
-      value
+      value,
     ) as DelegatedLocator<ValueType, NodeType>;
     locator.#delegate = this.#delegate.setWaitForEnabled(value);
     return locator;
@@ -846,10 +846,10 @@ export abstract class DelegatedLocator<T, U> extends Locator<U> {
     ElementType extends Element,
   >(
     this: DelegatedLocator<ValueType, ElementType>,
-    value: boolean
+    value: boolean,
   ): DelegatedLocator<ValueType, ElementType> {
     const locator = super.setEnsureElementIsInTheViewport<ElementType>(
-      value
+      value,
     ) as DelegatedLocator<ValueType, ElementType>;
     locator.#delegate = this.#delegate.setEnsureElementIsInTheViewport(value);
     return locator;
@@ -860,10 +860,10 @@ export abstract class DelegatedLocator<T, U> extends Locator<U> {
     ElementType extends Element,
   >(
     this: DelegatedLocator<ValueType, ElementType>,
-    value: boolean
+    value: boolean,
   ): DelegatedLocator<ValueType, ElementType> {
     const locator = super.setWaitForStableBoundingBox<ElementType>(
-      value
+      value,
     ) as DelegatedLocator<ValueType, ElementType>;
     locator.#delegate = this.#delegate.setWaitForStableBoundingBox(value);
     return locator;
@@ -890,7 +890,7 @@ export class FilteredLocator<From, To extends From> extends DelegatedLocator<
   override _clone(): FilteredLocator<From, To> {
     return new FilteredLocator(
       this.delegate.clone(),
-      this.#predicate
+      this.#predicate,
     ).copyOptions(this);
   }
 
@@ -898,7 +898,7 @@ export class FilteredLocator<From, To extends From> extends DelegatedLocator<
     return this.delegate._wait(options).pipe(
       mergeMap(handle => {
         return from(
-          Promise.resolve(this.#predicate(handle, options?.signal))
+          Promise.resolve(this.#predicate(handle, options?.signal)),
         ).pipe(
           filter(value => {
             return value;
@@ -906,10 +906,10 @@ export class FilteredLocator<From, To extends From> extends DelegatedLocator<
           map(() => {
             // SAFETY: It passed the predicate, so this is correct.
             return handle as HandleFor<To>;
-          })
+          }),
         );
       }),
-      throwIfEmpty()
+      throwIfEmpty(),
     );
   }
 }
@@ -923,7 +923,7 @@ export type Mapper<From, To> = (value: From) => Awaitable<To>;
  */
 export type HandleMapper<From, To> = (
   value: HandleFor<From>,
-  signal?: AbortSignal
+  signal?: AbortSignal,
 ) => Awaitable<HandleFor<To>>;
 /**
  * @internal
@@ -938,7 +938,7 @@ export class MappedLocator<From, To> extends DelegatedLocator<From, To> {
 
   override _clone(): MappedLocator<From, To> {
     return new MappedLocator(this.delegate.clone(), this.#mapper).copyOptions(
-      this
+      this,
     );
   }
 
@@ -946,7 +946,7 @@ export class MappedLocator<From, To> extends DelegatedLocator<From, To> {
     return this.delegate._wait(options).pipe(
       mergeMap(handle => {
         return from(Promise.resolve(this.#mapper(handle, options?.signal)));
-      })
+      }),
     );
   }
 }
@@ -956,7 +956,7 @@ export class MappedLocator<From, To> extends DelegatedLocator<From, To> {
  */
 export type Action<T, U> = (
   element: HandleFor<T>,
-  signal?: AbortSignal
+  signal?: AbortSignal,
 ) => Observable<U>;
 /**
  * @internal
@@ -964,12 +964,12 @@ export type Action<T, U> = (
 export class NodeLocator<T extends Node> extends Locator<T> {
   static create<Selector extends string>(
     pageOrFrame: Page | Frame,
-    selector: Selector
+    selector: Selector,
   ): Locator<NodeFor<Selector>> {
     return new NodeLocator<NodeFor<Selector>>(pageOrFrame, selector).setTimeout(
       'getDefaultTimeout' in pageOrFrame
         ? pageOrFrame.getDefaultTimeout()
-        : pageOrFrame.page().getDefaultTimeout()
+        : pageOrFrame.page().getDefaultTimeout(),
     );
   }
 
@@ -1010,7 +1010,7 @@ export class NodeLocator<T extends Node> extends Locator<T> {
 
   override _clone(): NodeLocator<T> {
     return new NodeLocator<T>(this.#pageOrFrame, this.#selector).copyOptions(
-      this
+      this,
     );
   }
 
@@ -1022,14 +1022,14 @@ export class NodeLocator<T extends Node> extends Locator<T> {
           visible: false,
           timeout: this._timeout,
           signal,
-        }) as Promise<HandleFor<T> | null>
+        }) as Promise<HandleFor<T> | null>,
       );
     }).pipe(
       filter((value): value is NonNullable<typeof value> => {
         return value !== null;
       }),
       throwIfEmpty(),
-      this.operators.conditions([this.#waitForVisibilityIfNeeded], signal)
+      this.operators.conditions([this.#waitForVisibilityIfNeeded], signal),
     );
   }
 }
@@ -1039,7 +1039,7 @@ export class NodeLocator<T extends Node> extends Locator<T> {
  */
 export type AwaitedLocator<T> = T extends Locator<infer S> ? S : never;
 function checkLocatorArray<T extends readonly unknown[] | []>(
-  locators: T
+  locators: T,
 ): ReadonlyArray<Locator<AwaitedLocator<T[number]>>> {
   for (const locator of locators) {
     if (!(locator instanceof Locator)) {
@@ -1053,7 +1053,7 @@ function checkLocatorArray<T extends readonly unknown[] | []>(
  */
 export class RaceLocator<T> extends Locator<T> {
   static create<T extends readonly unknown[]>(
-    locators: T
+    locators: T,
   ): Locator<AwaitedLocator<T[number]>> {
     const array = checkLocatorArray(locators);
     return new RaceLocator(array);
@@ -1070,7 +1070,7 @@ export class RaceLocator<T> extends Locator<T> {
     return new RaceLocator<T>(
       this.#locators.map(locator => {
         return locator.clone();
-      })
+      }),
     ).copyOptions(this);
   }
 
@@ -1078,7 +1078,7 @@ export class RaceLocator<T> extends Locator<T> {
     return race(
       ...this.#locators.map(locator => {
         return locator._wait(options);
-      })
+      }),
     );
   }
 }

package/front_end/third_party/puppeteer/package/src/bidi/BidiOverCdp.ts

@@ -24,7 +24,7 @@ const bidiServerLogger = (prefix: string, ...args: unknown[]): void => {
  * @internal
  */
 export async function connectBidiOverCdp(
-  cdp: CdpConnection
+  cdp: CdpConnection,
 ): Promise<BidiConnection> {
   const transportBiDi = new NoOpTransport();
   const cdpConnectionAdapter = new CdpConnectionAdapter(cdp);
@@ -50,7 +50,7 @@ export async function connectBidiOverCdp(
     cdp.url(),
     pptrTransport,
     cdp.delay,
-    cdp.timeout
+    cdp.timeout,
   );
   const bidiServer = await BidiMapper.BidiServer.createAndStart(
     transportBiDi,
@@ -58,7 +58,7 @@ export async function connectBidiOverCdp(
     cdpConnectionAdapter.browserClient(),
     /* selfTargetId= */ '',
     undefined,
-    bidiServerLogger
+    bidiServerLogger,
   );
   return pptrBiDiConnection;
 }
@@ -90,7 +90,7 @@ class CdpConnectionAdapter {
       const adapter = new CDPClientAdapter(
         session,
         id,
-        this.#browserCdpConnection
+        this.#browserCdpConnection,
       );
       this.#adapters.set(session, adapter);
       return adapter;
@@ -124,7 +124,7 @@ class CDPClientAdapter<T extends CDPSession | CdpConnection>
   constructor(
     client: T,
     sessionId?: string,
-    browserClient?: BidiMapper.CdpClient
+    browserClient?: BidiMapper.CdpClient,
   ) {
     super();
     this.#client = client;
@@ -139,7 +139,7 @@ class CDPClientAdapter<T extends CDPSession | CdpConnection>
 
   #forwardMessage = <T extends keyof CDPEvents>(
     method: T,
-    event: CDPEvents[T]
+    event: CDPEvents[T],
   ) => {
     this.emit(method, event);
   };
@@ -192,7 +192,7 @@ class NoOpTransport
   }
 
   setOnMessage(
-    onMessage: (message: Bidi.ChromiumBidi.Command) => Promise<void> | void
+    onMessage: (message: Bidi.ChromiumBidi.Command) => Promise<void> | void,
   ): void {
     this.#onMessage = onMessage;
   }

package/front_end/third_party/puppeteer/package/src/bidi/Browser.ts

@@ -82,13 +82,17 @@ export class BidiBrowser extends Browser {
           default: Bidi.Session.UserPromptHandlerType.Ignore,
         },
         webSocketUrl: true,
+        // Puppeteer with WebDriver BiDi does not support prerendering
+        // yet because WebDriver BiDi behavior is not specified. See
+        // https://github.com/w3c/webdriver-bidi/issues/321.
+        'goog:prerenderingDisabled': true,
       },
     });
 
     await session.subscribe(
       session.capabilities.browserName.toLocaleLowerCase().includes('firefox')
         ? BidiBrowser.subscribeModules
-        : [...BidiBrowser.subscribeModules, ...BidiBrowser.subscribeCdpEvents]
+        : [...BidiBrowser.subscribeModules, ...BidiBrowser.subscribeCdpEvents],
     );
 
     const browser = new BidiBrowser(session.browser, opts);
@@ -161,19 +165,19 @@ export class BidiBrowser extends Browser {
       BrowserContextEvent.TargetCreated,
       target => {
         this.#trustedEmitter.emit(BrowserEvent.TargetCreated, target);
-      }
+      },
     );
     browserContext.trustedEmitter.on(
       BrowserContextEvent.TargetChanged,
       target => {
         this.#trustedEmitter.emit(BrowserEvent.TargetChanged, target);
-      }
+      },
     );
     browserContext.trustedEmitter.on(
       BrowserContextEvent.TargetDestroyed,
       target => {
         this.#trustedEmitter.emit(BrowserEvent.TargetDestroyed, target);
-      }
+      },
     );
 
     return browserContext;
@@ -213,7 +217,7 @@ export class BidiBrowser extends Browser {
   }
 
   override async createBrowserContext(
-    _options?: BrowserContextOptions
+    _options?: BrowserContextOptions,
   ): Promise<BidiBrowserContext> {
     const userContext = await this.#browserCore.createUserContext();
     return this.#createBrowserContext(userContext);