How to use Accessibility method of Microsoft.Playwright.Core.Accessibility class

1/*
2 * MIT License
3 *
4 * Copyright (c) Microsoft Corporation.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25using System.Text.Json;
26using System.Threading.Tasks;
27using Microsoft.Playwright.Transport.Channels;
28
29namespace Microsoft.Playwright.Core
30{
31    internal class Accessibility : IAccessibility
32    {
33        private readonly PageChannel _channel;
34
35        public Accessibility(PageChannel channel)
36        {
37            _channel = channel;
38        }
39
40        public Task<JsonElement?> SnapshotAsync(AccessibilitySnapshotOptions options = default)
41        {
42            options ??= new();
43            return _channel.AccessibilitySnapshotAsync(options.InterestingOnly, (options.Root as ElementHandle)?.ElementChannel);
44        }
45    }
46}
47

Source: Accessibility.cs

/*
 * MIT License
 *
 * Copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Playwright.Transport.Channels;

namespace Microsoft.Playwright.Core
{
    internal class Accessibility : IAccessibility
    {
        private readonly PageChannel _channel;

        public Accessibility(PageChannel channel)
        {
            _channel = channel;
        }

        public Task<JsonElement?> SnapshotAsync(AccessibilitySnapshotOptions options = default)
        {
            options ??= new();
            return _channel.AccessibilitySnapshotAsync(options.InterestingOnly, (options.Root as ElementHandle)?.ElementChannel);
        }
    }
}

1/*
2 * MIT License
3 *
4 * Copyright (c) 2020 Darío Kondratiuk
5 * Modifications copyright (c) Microsoft Corporation.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 */
25using System;
26using System.Collections.Generic;
27using System.Linq;
28using System.Text.Json;
29using System.Threading.Tasks;
30using Microsoft.Playwright.Core;
31using Microsoft.Playwright.Helpers;
32using Microsoft.Playwright.Transport.Protocol;
33
34namespace Microsoft.Playwright.Transport.Channels
35{
36    internal class PageChannel : Channel<Page>
37    {
38        public PageChannel(string guid, Connection connection, Page owner) : base(guid, connection, owner)
39        {
40        }
41
42        internal event EventHandler Closed;
43
44        internal event EventHandler Crashed;
45
46        internal event EventHandler<IWebSocket> WebSocket;
47
48        internal event EventHandler DOMContentLoaded;
49
50        internal event EventHandler<PageChannelPopupEventArgs> Popup;
51
52        internal event EventHandler<BindingCallEventArgs> BindingCall;
53
54        internal event EventHandler<RouteEventArgs> Route;
55
56        internal event EventHandler<IFrame> FrameAttached;
57
58        internal event EventHandler<IFrame> FrameDetached;
59
60        internal event EventHandler<IDialog> Dialog;
61
62        internal event EventHandler<IConsoleMessage> Console;
63
64        internal event EventHandler<PageDownloadEvent> Download;
65
66        internal event EventHandler<SerializedError> PageError;
67
68        internal event EventHandler<FileChooserChannelEventArgs> FileChooser;
69
70        internal event EventHandler Load;
71
72        internal event EventHandler<WorkerChannelEventArgs> Worker;
73
74        internal event EventHandler<VideoEventArgs> Video;
75
76        internal override void OnMessage(string method, JsonElement? serverParams)
77        {
78            switch (method)
79            {
80                case "close":
81                    Closed?.Invoke(this, EventArgs.Empty);
82                    break;
83                case "crash":
84                    Crashed?.Invoke(this, EventArgs.Empty);
85                    break;
86                case "domcontentloaded":
87                    DOMContentLoaded?.Invoke(this, EventArgs.Empty);
88                    break;
89                case "load":
90                    Load?.Invoke(this, EventArgs.Empty);
91                    break;
92                case "bindingCall":
93                    BindingCall?.Invoke(
94                        this,
95                        new() { BindingCall = serverParams?.GetProperty("binding").ToObject<BindingCallChannel>(Connection.DefaultJsonSerializerOptions).Object });
96                    break;
97                case "route":
98                    var route = serverParams?.GetProperty("route").ToObject<RouteChannel>(Connection.DefaultJsonSerializerOptions).Object;
99                    var request = serverParams?.GetProperty("request").ToObject<RequestChannel>(Connection.DefaultJsonSerializerOptions).Object;
100                    Route?.Invoke(
101                        this,
102                        new() { Route = route, Request = request });
103                    break;
104                case "popup":
105                    Popup?.Invoke(this, new() { Page = serverParams?.GetProperty("page").ToObject<PageChannel>(Connection.DefaultJsonSerializerOptions).Object });
106                    break;
107                case "pageError":
108                    PageError?.Invoke(this, serverParams?.GetProperty("error").GetProperty("error").ToObject<SerializedError>(Connection.DefaultJsonSerializerOptions));
109                    break;
110                case "fileChooser":
111                    FileChooser?.Invoke(this, serverParams?.ToObject<FileChooserChannelEventArgs>(Connection.DefaultJsonSerializerOptions));
112                    break;
113                case "frameAttached":
114                    FrameAttached?.Invoke(this, serverParams?.GetProperty("frame").ToObject<FrameChannel>(Connection.DefaultJsonSerializerOptions).Object);
115                    break;
116                case "frameDetached":
117                    FrameDetached?.Invoke(this, serverParams?.GetProperty("frame").ToObject<FrameChannel>(Connection.DefaultJsonSerializerOptions).Object);
118                    break;
119                case "dialog":
120                    Dialog?.Invoke(this, serverParams?.GetProperty("dialog").ToObject<DialogChannel>(Connection.DefaultJsonSerializerOptions).Object);
121                    break;
122                case "console":
123                    Console?.Invoke(this, serverParams?.GetProperty("message").ToObject<ConsoleMessage>(Connection.DefaultJsonSerializerOptions));
124                    break;
125                case "webSocket":
126                    WebSocket?.Invoke(this, serverParams?.GetProperty("webSocket").ToObject<WebSocketChannel>(Connection.DefaultJsonSerializerOptions).Object);
127                    break;
128                case "download":
129                    Download?.Invoke(this, serverParams?.ToObject<PageDownloadEvent>(Connection.DefaultJsonSerializerOptions));
130                    break;
131                case "video":
132                    Video?.Invoke(this, new() { Artifact = serverParams?.GetProperty("artifact").ToObject<ArtifactChannel>(Connection.DefaultJsonSerializerOptions).Object });
133                    break;
134                case "worker":
135                    Worker?.Invoke(
136                        this,
137                        new() { WorkerChannel = serverParams?.GetProperty("worker").ToObject<WorkerChannel>(Connection.DefaultJsonSerializerOptions) });
138                    break;
139            }
140        }
141
142        internal Task SetDefaultTimeoutNoReplyAsync(float timeout)
143            => Connection.SendMessageToServerAsync<PageChannel>(
144                Guid,
145                "setDefaultTimeoutNoReply",
146                new Dictionary<string, object>
147                {
148                    ["timeout"] = timeout,
149                });
150
151        internal Task SetDefaultNavigationTimeoutNoReplyAsync(float timeout)
152            => Connection.SendMessageToServerAsync<PageChannel>(
153                Guid,
154                "setDefaultNavigationTimeoutNoReply",
155                new Dictionary<string, object>
156                {
157                    ["timeout"] = timeout,
158                });
159
160        internal Task SetFileChooserInterceptedNoReplyAsync(bool intercepted)
161            => Connection.SendMessageToServerAsync<PageChannel>(
162                Guid,
163                "setFileChooserInterceptedNoReply",
164                new Dictionary<string, object>
165                {
166                    ["intercepted"] = intercepted,
167                });
168
169        internal Task CloseAsync(bool runBeforeUnload)
170            => Connection.SendMessageToServerAsync(
171                Guid,
172                "close",
173                new Dictionary<string, object>
174                {
175                    ["runBeforeUnload"] = runBeforeUnload,
176                });
177
178        internal Task ExposeBindingAsync(string name, bool needsHandle)
179            => Connection.SendMessageToServerAsync<PageChannel>(
180                Guid,
181                "exposeBinding",
182                new Dictionary<string, object>
183                {
184                    ["name"] = name,
185                    ["needsHandle"] = needsHandle,
186                });
187
188        internal Task AddInitScriptAsync(string script)
189            => Connection.SendMessageToServerAsync<PageChannel>(
190                Guid,
191                "addInitScript",
192                new Dictionary<string, object>
193                {
194                    ["source"] = script,
195                });
196
197        internal Task BringToFrontAsync() => Connection.SendMessageToServerAsync(Guid, "bringToFront");
198
199        internal Task<ResponseChannel> GoBackAsync(float? timeout, WaitUntilState? waitUntil)
200        {
201            var args = new Dictionary<string, object>
202            {
203                ["timeout"] = timeout,
204                ["waitUntil"] = waitUntil,
205            };
206            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "goBack", args);
207        }
208
209        internal Task<ResponseChannel> GoForwardAsync(float? timeout, WaitUntilState? waitUntil)
210        {
211            var args = new Dictionary<string, object>
212            {
213                ["timeout"] = timeout,
214                ["waitUntil"] = waitUntil,
215            };
216            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "goForward", args);
217        }
218
219        internal Task<ResponseChannel> ReloadAsync(float? timeout, WaitUntilState? waitUntil)
220        {
221            var args = new Dictionary<string, object>
222            {
223                ["timeout"] = timeout,
224                ["waitUntil"] = waitUntil,
225            };
226            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "reload", args);
227        }
228
229        internal Task SetNetworkInterceptionEnabledAsync(bool enabled)
230            => Connection.SendMessageToServerAsync<PageChannel>(
231                Guid,
232                "setNetworkInterceptionEnabled",
233                new Dictionary<string, object>
234                {
235                    ["enabled"] = enabled,
236                });
237
238        internal async Task<JsonElement?> AccessibilitySnapshotAsync(bool? interestingOnly, IChannel<ElementHandle> root)
239        {
240            var args = new Dictionary<string, object>
241            {
242                ["interestingOnly"] = interestingOnly,
243                ["root"] = root,
244            };
245
246            if ((await Connection.SendMessageToServerAsync(Guid, "accessibilitySnapshot", args).ConfigureAwait(false)).Value.TryGetProperty("rootAXNode", out var jsonElement))
247            {
248                return jsonElement;
249            }
250
251            return null;
252        }
253
254        internal Task SetViewportSizeAsync(PageViewportSizeResult viewport)
255            => Connection.SendMessageToServerAsync(
256                Guid,
257                "setViewportSize",
258                new Dictionary<string, object>
259                {
260                    ["viewportSize"] = viewport,
261                });
262
263        internal Task KeyboardDownAsync(string key)
264            => Connection.SendMessageToServerAsync(
265                Guid,
266                "keyboardDown",
267                new Dictionary<string, object>
268                {
269                    ["key"] = key,
270                });
271
272        internal Task EmulateMediaAsync(Dictionary<string, object> args)
273            => Connection.SendMessageToServerAsync(Guid, "emulateMedia", args);
274
275        internal Task KeyboardUpAsync(string key)
276            => Connection.SendMessageToServerAsync(
277                Guid,
278                "keyboardUp",
279                new Dictionary<string, object>
280                {
281                    ["key"] = key,
282                });
283
284        internal Task TypeAsync(string text, float? delay)
285            => Connection.SendMessageToServerAsync(
286                Guid,
287                "keyboardType",
288                new Dictionary<string, object>
289                {
290                    ["text"] = text,
291                    ["delay"] = delay,
292                });
293
294        internal Task PressAsync(string key, float? delay)
295            => Connection.SendMessageToServerAsync(
296                Guid,
297                "keyboardPress",
298                new Dictionary<string, object>
299                {
300                    ["key"] = key,
301                    ["delay"] = delay,
302                });
303
304        internal Task InsertTextAsync(string text)
305            => Connection.SendMessageToServerAsync(
306                Guid,
307                "keyboardInsertText",
308                new Dictionary<string, object>
309                {
310                    ["text"] = text,
311                });
312
313        internal Task MouseDownAsync(MouseButton? button, int? clickCount)
314            => Connection.SendMessageToServerAsync(
315                Guid,
316                "mouseDown",
317                new Dictionary<string, object>
318                {
319                    ["button"] = button,
320                    ["clickCount"] = clickCount,
321                });
322
323        internal Task MouseMoveAsync(float x, float y, int? steps)
324            => Connection.SendMessageToServerAsync(
325                Guid,
326                "mouseMove",
327                new Dictionary<string, object>
328                {
329                    ["x"] = x,
330                    ["y"] = y,
331                    ["steps"] = steps,
332                });
333
334        internal Task MouseUpAsync(MouseButton? button, int? clickCount)
335            => Connection.SendMessageToServerAsync(
336                Guid,
337                "mouseUp",
338                new Dictionary<string, object>
339                {
340                    ["button"] = button,
341                    ["clickCount"] = clickCount,
342                });
343
344        internal Task MouseClickAsync(float x, float y, float? delay, MouseButton? button, int? clickCount)
345            => Connection.SendMessageToServerAsync(
346                Guid,
347                "mouseClick",
348                new Dictionary<string, object>
349                {
350                    ["x"] = x,
351                    ["y"] = y,
352                    ["delay"] = delay,
353                    ["button"] = button,
354                    ["clickCount"] = clickCount,
355                });
356
357        internal Task MouseWheelAsync(float deltaX, float deltaY)
358            => Connection.SendMessageToServerAsync(
359                Guid,
360                "mouseWheel",
361                new Dictionary<string, object>
362                {
363                    ["deltaX"] = deltaX,
364                    ["deltaY"] = deltaY,
365                });
366
367        internal Task TouchscreenTapAsync(float x, float y)
368            => Connection.SendMessageToServerAsync(
369                Guid,
370                "touchscreenTap",
371                new Dictionary<string, object>
372                {
373                    ["x"] = x,
374                    ["y"] = y,
375                });
376
377        internal Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
378            => Connection.SendMessageToServerAsync(
379                Guid,
380                "setExtraHTTPHeaders",
381                new Dictionary<string, object>
382                {
383                    ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
384                });
385
386        internal async Task<byte[]> ScreenshotAsync(
387            string path,
388            bool? fullPage,
389            Clip clip,
390            bool? omitBackground,
391            ScreenshotType? type,
392            int? quality,
393            IEnumerable<ILocator> mask,
394            ScreenshotAnimations? animations,
395            ScreenshotCaret? caret,
396            ScreenshotScale? scale,
397            float? timeout)
398        {
399            var args = new Dictionary<string, object>
400            {
401                ["fullPage"] = fullPage,
402                ["omitBackground"] = omitBackground,
403                ["clip"] = clip,
404                ["path"] = path,
405                ["type"] = type,
406                ["timeout"] = timeout,
407                ["animations"] = animations,
408                ["caret"] = caret,
409                ["scale"] = scale,
410                ["quality"] = quality,
411            };
412            if (mask != null)
413            {
414                args["mask"] = mask.Select(locator => new Dictionary<string, object>
415                {
416                    ["frame"] = ((Locator)locator)._frame._channel,
417                    ["selector"] = ((Locator)locator)._selector,
418                }).ToArray();
419            }
420            return (await Connection.SendMessageToServerAsync(Guid, "screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
421        }
422
423        internal Task StartCSSCoverageAsync(bool resetOnNavigation)
424            => Connection.SendMessageToServerAsync(
425                Guid,
426                "crStartCSSCoverage",
427                new Dictionary<string, object>
428                {
429                    ["resetOnNavigation"] = resetOnNavigation,
430                });
431
432        internal Task StartJSCoverageAsync(bool resetOnNavigation, bool reportAnonymousScripts)
433            => Connection.SendMessageToServerAsync(
434                Guid,
435                "crStartJSCoverage",
436                new Dictionary<string, object>
437                {
438                    ["resetOnNavigation"] = resetOnNavigation,
439                    ["reportAnonymousScripts"] = reportAnonymousScripts,
440                });
441
442        internal async Task<byte[]> PdfAsync(
443            float? scale,
444            bool? displayHeaderFooter,
445            string headerTemplate,
446            string footerTemplate,
447            bool? printBackground,
448            bool? landscape,
449            string pageRanges,
450            string format,
451            string width,
452            string height,
453            Margin margin,
454            bool? preferCSSPageSize)
455        {
456            var args = new Dictionary<string, object>
457            {
458                ["scale"] = scale,
459                ["displayHeaderFooter"] = displayHeaderFooter,
460                ["printBackground"] = printBackground,
461                ["landscape"] = landscape,
462                ["preferCSSPageSize"] = preferCSSPageSize,
463                ["pageRanges"] = pageRanges,
464                ["headerTemplate"] = headerTemplate,
465                ["footerTemplate"] = footerTemplate,
466                ["margin"] = margin,
467                ["width"] = width,
468                ["format"] = format,
469                ["height"] = height,
470            };
471            return (await Connection.SendMessageToServerAsync(Guid, "pdf", args).ConfigureAwait(false))?.GetProperty("pdf").GetBytesFromBase64();
472        }
473    }
474}
475

Source: PageChannel.cs

/*
 * MIT License
 *
 * Copyright (c) 2020 Darío Kondratiuk
 * Modifications copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Playwright.Core;
using Microsoft.Playwright.Helpers;
using Microsoft.Playwright.Transport.Protocol;

namespace Microsoft.Playwright.Transport.Channels
{
    internal class PageChannel : Channel<Page>
    {
        public PageChannel(string guid, Connection connection, Page owner) : base(guid, connection, owner)
        {
        }

        internal event EventHandler Closed;

        internal event EventHandler Crashed;

        internal event EventHandler<IWebSocket> WebSocket;

        internal event EventHandler DOMContentLoaded;

        internal event EventHandler<PageChannelPopupEventArgs> Popup;

        internal event EventHandler<BindingCallEventArgs> BindingCall;

        internal event EventHandler<RouteEventArgs> Route;

        internal event EventHandler<IFrame> FrameAttached;

        internal event EventHandler<IFrame> FrameDetached;

        internal event EventHandler<IDialog> Dialog;

        internal event EventHandler<IConsoleMessage> Console;

        internal event EventHandler<PageDownloadEvent> Download;

        internal event EventHandler<SerializedError> PageError;

        internal event EventHandler<FileChooserChannelEventArgs> FileChooser;

        internal event EventHandler Load;

        internal event EventHandler<WorkerChannelEventArgs> Worker;

        internal event EventHandler<VideoEventArgs> Video;

        internal override void OnMessage(string method, JsonElement? serverParams)
        {
            switch (method)
            {
                case "close":
                    Closed?.Invoke(this, EventArgs.Empty);
                    break;
                case "crash":
                    Crashed?.Invoke(this, EventArgs.Empty);
                    break;
                case "domcontentloaded":
                    DOMContentLoaded?.Invoke(this, EventArgs.Empty);
                    break;
                case "load":
                    Load?.Invoke(this, EventArgs.Empty);
                    break;
                case "bindingCall":
                    BindingCall?.Invoke(
                        this,
                        new() { BindingCall = serverParams?.GetProperty("binding").ToObject<BindingCallChannel>(Connection.DefaultJsonSerializerOptions).Object });
                    break;
                case "route":
                    var route = serverParams?.GetProperty("route").ToObject<RouteChannel>(Connection.DefaultJsonSerializerOptions).Object;
                    var request = serverParams?.GetProperty("request").ToObject<RequestChannel>(Connection.DefaultJsonSerializerOptions).Object;
                    Route?.Invoke(
                        this,
                        new() { Route = route, Request = request });
                    break;
                case "popup":
                    Popup?.Invoke(this, new() { Page = serverParams?.GetProperty("page").ToObject<PageChannel>(Connection.DefaultJsonSerializerOptions).Object });
                    break;
                case "pageError":
                    PageError?.Invoke(this, serverParams?.GetProperty("error").GetProperty("error").ToObject<SerializedError>(Connection.DefaultJsonSerializerOptions));
                    break;
                case "fileChooser":
                    FileChooser?.Invoke(this, serverParams?.ToObject<FileChooserChannelEventArgs>(Connection.DefaultJsonSerializerOptions));
                    break;
                case "frameAttached":
                    FrameAttached?.Invoke(this, serverParams?.GetProperty("frame").ToObject<FrameChannel>(Connection.DefaultJsonSerializerOptions).Object);
                    break;
                case "frameDetached":
                    FrameDetached?.Invoke(this, serverParams?.GetProperty("frame").ToObject<FrameChannel>(Connection.DefaultJsonSerializerOptions).Object);
                    break;
                case "dialog":
                    Dialog?.Invoke(this, serverParams?.GetProperty("dialog").ToObject<DialogChannel>(Connection.DefaultJsonSerializerOptions).Object);
                    break;
                case "console":
                    Console?.Invoke(this, serverParams?.GetProperty("message").ToObject<ConsoleMessage>(Connection.DefaultJsonSerializerOptions));
                    break;
                case "webSocket":
                    WebSocket?.Invoke(this, serverParams?.GetProperty("webSocket").ToObject<WebSocketChannel>(Connection.DefaultJsonSerializerOptions).Object);
                    break;
                case "download":
                    Download?.Invoke(this, serverParams?.ToObject<PageDownloadEvent>(Connection.DefaultJsonSerializerOptions));
                    break;
                case "video":
                    Video?.Invoke(this, new() { Artifact = serverParams?.GetProperty("artifact").ToObject<ArtifactChannel>(Connection.DefaultJsonSerializerOptions).Object });
                    break;
                case "worker":
                    Worker?.Invoke(
                        this,
                        new() { WorkerChannel = serverParams?.GetProperty("worker").ToObject<WorkerChannel>(Connection.DefaultJsonSerializerOptions) });
                    break;
            }
        }

        internal Task SetDefaultTimeoutNoReplyAsync(float timeout)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "setDefaultTimeoutNoReply",
                new Dictionary<string, object>
                {
                    ["timeout"] = timeout,
                });

        internal Task SetDefaultNavigationTimeoutNoReplyAsync(float timeout)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "setDefaultNavigationTimeoutNoReply",
                new Dictionary<string, object>
                {
                    ["timeout"] = timeout,
                });

        internal Task SetFileChooserInterceptedNoReplyAsync(bool intercepted)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "setFileChooserInterceptedNoReply",
                new Dictionary<string, object>
                {
                    ["intercepted"] = intercepted,
                });

        internal Task CloseAsync(bool runBeforeUnload)
            => Connection.SendMessageToServerAsync(
                Guid,
                "close",
                new Dictionary<string, object>
                {
                    ["runBeforeUnload"] = runBeforeUnload,
                });

        internal Task ExposeBindingAsync(string name, bool needsHandle)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "exposeBinding",
                new Dictionary<string, object>
                {
                    ["name"] = name,
                    ["needsHandle"] = needsHandle,
                });

        internal Task AddInitScriptAsync(string script)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "addInitScript",
                new Dictionary<string, object>
                {
                    ["source"] = script,
                });

        internal Task BringToFrontAsync() => Connection.SendMessageToServerAsync(Guid, "bringToFront");

        internal Task<ResponseChannel> GoBackAsync(float? timeout, WaitUntilState? waitUntil)
        {
            var args = new Dictionary<string, object>
            {
                ["timeout"] = timeout,
                ["waitUntil"] = waitUntil,
            };
            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "goBack", args);
        }

        internal Task<ResponseChannel> GoForwardAsync(float? timeout, WaitUntilState? waitUntil)
        {
            var args = new Dictionary<string, object>
            {
                ["timeout"] = timeout,
                ["waitUntil"] = waitUntil,
            };
            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "goForward", args);
        }

        internal Task<ResponseChannel> ReloadAsync(float? timeout, WaitUntilState? waitUntil)
        {
            var args = new Dictionary<string, object>
            {
                ["timeout"] = timeout,
                ["waitUntil"] = waitUntil,
            };
            return Connection.SendMessageToServerAsync<ResponseChannel>(Guid, "reload", args);
        }

        internal Task SetNetworkInterceptionEnabledAsync(bool enabled)
            => Connection.SendMessageToServerAsync<PageChannel>(
                Guid,
                "setNetworkInterceptionEnabled",
                new Dictionary<string, object>
                {
                    ["enabled"] = enabled,
                });

        internal async Task<JsonElement?> AccessibilitySnapshotAsync(bool? interestingOnly, IChannel<ElementHandle> root)
        {
            var args = new Dictionary<string, object>
            {
                ["interestingOnly"] = interestingOnly,
                ["root"] = root,
            };

            if ((await Connection.SendMessageToServerAsync(Guid, "accessibilitySnapshot", args).ConfigureAwait(false)).Value.TryGetProperty("rootAXNode", out var jsonElement))
            {
                return jsonElement;
            }

            return null;
        }

        internal Task SetViewportSizeAsync(PageViewportSizeResult viewport)
            => Connection.SendMessageToServerAsync(
                Guid,
                "setViewportSize",
                new Dictionary<string, object>
                {
                    ["viewportSize"] = viewport,
                });

        internal Task KeyboardDownAsync(string key)
            => Connection.SendMessageToServerAsync(
                Guid,
                "keyboardDown",
                new Dictionary<string, object>
                {
                    ["key"] = key,
                });

        internal Task EmulateMediaAsync(Dictionary<string, object> args)
            => Connection.SendMessageToServerAsync(Guid, "emulateMedia", args);

        internal Task KeyboardUpAsync(string key)
            => Connection.SendMessageToServerAsync(
                Guid,
                "keyboardUp",
                new Dictionary<string, object>
                {
                    ["key"] = key,
                });

        internal Task TypeAsync(string text, float? delay)
            => Connection.SendMessageToServerAsync(
                Guid,
                "keyboardType",
                new Dictionary<string, object>
                {
                    ["text"] = text,
                    ["delay"] = delay,
                });

        internal Task PressAsync(string key, float? delay)
            => Connection.SendMessageToServerAsync(
                Guid,
                "keyboardPress",
                new Dictionary<string, object>
                {
                    ["key"] = key,
                    ["delay"] = delay,
                });

        internal Task InsertTextAsync(string text)
            => Connection.SendMessageToServerAsync(
                Guid,
                "keyboardInsertText",
                new Dictionary<string, object>
                {
                    ["text"] = text,
                });

        internal Task MouseDownAsync(MouseButton? button, int? clickCount)
            => Connection.SendMessageToServerAsync(
                Guid,
                "mouseDown",
                new Dictionary<string, object>
                {
                    ["button"] = button,
                    ["clickCount"] = clickCount,
                });

        internal Task MouseMoveAsync(float x, float y, int? steps)
            => Connection.SendMessageToServerAsync(
                Guid,
                "mouseMove",
                new Dictionary<string, object>
                {
                    ["x"] = x,
                    ["y"] = y,
                    ["steps"] = steps,
                });

        internal Task MouseUpAsync(MouseButton? button, int? clickCount)
            => Connection.SendMessageToServerAsync(
                Guid,
                "mouseUp",
                new Dictionary<string, object>
                {
                    ["button"] = button,
                    ["clickCount"] = clickCount,
                });

        internal Task MouseClickAsync(float x, float y, float? delay, MouseButton? button, int? clickCount)
            => Connection.SendMessageToServerAsync(
                Guid,
                "mouseClick",
                new Dictionary<string, object>
                {
                    ["x"] = x,
                    ["y"] = y,
                    ["delay"] = delay,
                    ["button"] = button,
                    ["clickCount"] = clickCount,
                });

        internal Task MouseWheelAsync(float deltaX, float deltaY)
            => Connection.SendMessageToServerAsync(
                Guid,
                "mouseWheel",
                new Dictionary<string, object>
                {
                    ["deltaX"] = deltaX,
                    ["deltaY"] = deltaY,
                });

        internal Task TouchscreenTapAsync(float x, float y)
            => Connection.SendMessageToServerAsync(
                Guid,
                "touchscreenTap",
                new Dictionary<string, object>
                {
                    ["x"] = x,
                    ["y"] = y,
                });

        internal Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
            => Connection.SendMessageToServerAsync(
                Guid,
                "setExtraHTTPHeaders",
                new Dictionary<string, object>
                {
                    ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
                });

        internal async Task<byte[]> ScreenshotAsync(
            string path,
            bool? fullPage,
            Clip clip,
            bool? omitBackground,
            ScreenshotType? type,
            int? quality,
            IEnumerable<ILocator> mask,
            ScreenshotAnimations? animations,
            ScreenshotCaret? caret,
            ScreenshotScale? scale,
            float? timeout)
        {
            var args = new Dictionary<string, object>
            {
                ["fullPage"] = fullPage,
                ["omitBackground"] = omitBackground,
                ["clip"] = clip,
                ["path"] = path,
                ["type"] = type,
                ["timeout"] = timeout,
                ["animations"] = animations,
                ["caret"] = caret,
                ["scale"] = scale,
                ["quality"] = quality,
            };
            if (mask != null)
            {
                args["mask"] = mask.Select(locator => new Dictionary<string, object>
                {
                    ["frame"] = ((Locator)locator)._frame._channel,
                    ["selector"] = ((Locator)locator)._selector,
                }).ToArray();
            }
            return (await Connection.SendMessageToServerAsync(Guid, "screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
        }

        internal Task StartCSSCoverageAsync(bool resetOnNavigation)
            => Connection.SendMessageToServerAsync(
                Guid,
                "crStartCSSCoverage",
                new Dictionary<string, object>
                {
                    ["resetOnNavigation"] = resetOnNavigation,
                });

        internal Task StartJSCoverageAsync(bool resetOnNavigation, bool reportAnonymousScripts)
            => Connection.SendMessageToServerAsync(
                Guid,
                "crStartJSCoverage",
                new Dictionary<string, object>
                {
                    ["resetOnNavigation"] = resetOnNavigation,
                    ["reportAnonymousScripts"] = reportAnonymousScripts,
                });

        internal async Task<byte[]> PdfAsync(
            float? scale,
            bool? displayHeaderFooter,
            string headerTemplate,
            string footerTemplate,
            bool? printBackground,
            bool? landscape,
            string pageRanges,
            string format,
            string width,
            string height,
            Margin margin,
            bool? preferCSSPageSize)
        {
            var args = new Dictionary<string, object>
            {
                ["scale"] = scale,
                ["displayHeaderFooter"] = displayHeaderFooter,
                ["printBackground"] = printBackground,
                ["landscape"] = landscape,
                ["preferCSSPageSize"] = preferCSSPageSize,
                ["pageRanges"] = pageRanges,
                ["headerTemplate"] = headerTemplate,
                ["footerTemplate"] = footerTemplate,
                ["margin"] = margin,
                ["width"] = width,
                ["format"] = format,
                ["height"] = height,
            };
            return (await Connection.SendMessageToServerAsync(Guid, "pdf", args).ConfigureAwait(false))?.GetProperty("pdf").GetBytesFromBase64();
        }
    }
}

1/*
2 * MIT License
3 *
4 * Copyright (c) 2020 Darío Kondratiuk
5 * Copyright (c) 2020 Meir Blachman
6 * Modifications copyright (c) Microsoft Corporation.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included in all
16 * copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24 * SOFTWARE.
25 */
26using System;
27using System.Collections.Generic;
28using System.Data.SqlTypes;
29using System.IO;
30using System.Linq;
31using System.Text.Json;
32using System.Text.RegularExpressions;
33using System.Threading.Tasks;
34using Microsoft.Playwright.Helpers;
35using Microsoft.Playwright.Transport;
36using Microsoft.Playwright.Transport.Channels;
37using Microsoft.Playwright.Transport.Protocol;
38
39namespace Microsoft.Playwright.Core
40{
41    internal partial class Page : ChannelOwnerBase, IChannelOwner<Page>, IPage
42    {
43        private readonly PageChannel _channel;
44        private readonly List<Frame> _frames = new();
45        private readonly List<(IEvent PageEvent, TaskCompletionSource<bool> WaitTcs)> _waitForCancellationTcs = new();
46        private readonly object _fileChooserEventLock = new();
47        private readonly IAccessibility _accessibility;
48        private readonly IMouse _mouse;
49        private readonly IKeyboard _keyboard;
50        private readonly ITouchscreen _touchscreen;
51        private readonly PageInitializer _initializer;
52
53        private List<RouteSetting> _routes = new();
54        private EventHandler<IFileChooser> _fileChooserEventHandler;
55        private bool _fileChooserIntercepted;
56        private Video _video;
57        private float _defaultNavigationTimeout;
58        private float _defaultTimeout;
59
60        internal Page(IChannelOwner parent, string guid, PageInitializer initializer) : base(parent, guid)
61        {
62            Context = (BrowserContext)parent;
63
64            _channel = new(guid, parent.Connection, this);
65
66            MainFrame = initializer.MainFrame;
67            MainFrame.Page = this;
68            _frames.Add(MainFrame);
69            if (initializer.ViewportSize != null)
70            {
71                ViewportSize = new() { Width = initializer.ViewportSize.Width, Height = initializer.ViewportSize.Height };
72            }
73
74            IsClosed = initializer.IsClosed;
75            _accessibility = new Accessibility(_channel);
76            _keyboard = new Keyboard(_channel);
77            _touchscreen = new Touchscreen(_channel);
78            _mouse = new Mouse(_channel);
79            _channel.Closed += (_, _) => OnClose();
80            _channel.Crashed += Channel_Crashed;
81            _channel.Popup += (_, e) => Popup?.Invoke(this, e.Page);
82            _channel.WebSocket += (_, e) => WebSocket?.Invoke(this, e);
83            _channel.BindingCall += Channel_BindingCall;
84            _channel.Route += (_, e) => OnRoute(e.Route, e.Request);
85            _channel.FrameAttached += Channel_FrameAttached;
86            _channel.FrameDetached += Channel_FrameDetached;
87            _channel.Dialog += (_, e) =>
88            {
89                if (Dialog == null)
90                {
91                    if ("beforeunload".Equals(e.Type, StringComparison.Ordinal))
92                    {
93                        e.AcceptAsync(null).IgnoreException();
94                    }
95                    else
96                    {
97                        e.DismissAsync().IgnoreException();
98                    }
99                }
100                else
101                {
102                    Dialog?.Invoke(this, e);
103                }
104            };
105            _channel.Console += (_, e) => Console?.Invoke(this, e);
106            _channel.DOMContentLoaded += (_, _) => DOMContentLoaded?.Invoke(this, this);
107            _channel.Download += (_, e) => Download?.Invoke(this, new Download(this, e.Url, e.SuggestedFilename, e.Artifact.Object));
108            _channel.PageError += (_, e) => PageError?.Invoke(this, e.ToString());
109            _channel.Load += (_, _) => Load?.Invoke(this, this);
110            _channel.Video += (_, e) => ForceVideo().ArtifactReady(e.Artifact);
111
112            _channel.FileChooser += (_, e) => _fileChooserEventHandler?.Invoke(this, new FileChooser(this, e.Element.Object, e.IsMultiple));
113            _channel.Worker += (_, e) =>
114            {
115                WorkersList.Add(e.WorkerChannel.Object);
116                e.WorkerChannel.Object.Page = this;
117                Worker?.Invoke(this, e.WorkerChannel.Object);
118            };
119
120            _defaultNavigationTimeout = Context.DefaultNavigationTimeout;
121            _defaultTimeout = Context.DefaultTimeout;
122            _initializer = initializer;
123
124            Close += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);
125            Crash += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);
126        }
127
128        public event EventHandler<IConsoleMessage> Console;
129
130        public event EventHandler<IPage> Popup;
131
132        public event EventHandler<IRequest> Request;
133
134        public event EventHandler<IWebSocket> WebSocket;
135
136        public event EventHandler<IResponse> Response;
137
138        public event EventHandler<IRequest> RequestFinished;
139
140        public event EventHandler<IRequest> RequestFailed;
141
142        public event EventHandler<IDialog> Dialog;
143
144        public event EventHandler<IFrame> FrameAttached;
145
146        public event EventHandler<IFrame> FrameDetached;
147
148        public event EventHandler<IFrame> FrameNavigated;
149
150        public event EventHandler<IFileChooser> FileChooser
151        {
152            add
153            {
154                lock (_fileChooserEventLock)
155                {
156                    _fileChooserEventHandler += value;
157                    _fileChooserIntercepted = true;
158                    _channel.SetFileChooserInterceptedNoReplyAsync(true).IgnoreException();
159                }
160            }
161
162            remove
163            {
164                lock (_fileChooserEventLock)
165                {
166                    _fileChooserEventHandler -= value;
167
168                    if (_fileChooserIntercepted)
169                    {
170                        _fileChooserIntercepted = false;
171                        _channel.SetFileChooserInterceptedNoReplyAsync(false).IgnoreException();
172                    }
173                }
174            }
175        }
176
177        public event EventHandler<IPage> Load;
178
179        public event EventHandler<IPage> DOMContentLoaded;
180
181        public event EventHandler<IPage> Close;
182
183        public event EventHandler<IPage> Crash;
184
185        public event EventHandler<string> PageError;
186
187        public event EventHandler<IWorker> Worker;
188
189        public event EventHandler<IDownload> Download;
190
191        ChannelBase IChannelOwner.Channel => _channel;
192
193        IChannel<Page> IChannelOwner<Page>.Channel => _channel;
194
195        public bool IsClosed { get; private set; }
196
197        IFrame IPage.MainFrame => MainFrame;
198
199        public Frame MainFrame { get; }
200
201        IBrowserContext IPage.Context => Context;
202
203        public BrowserContext Context { get; set; }
204
205        public PageViewportSizeResult ViewportSize { get; private set; }
206
207        public IAccessibility Accessibility
208        {
209            get => _accessibility;
210            set => throw new NotSupportedException();
211        }
212
213        public IMouse Mouse
214        {
215            get => _mouse;
216            set => throw new NotSupportedException();
217        }
218
219        public string Url => MainFrame.Url;
220
221        public IReadOnlyList<IFrame> Frames => _frames.AsReadOnly();
222
223        public IKeyboard Keyboard
224        {
225            get => _keyboard;
226        }
227
228        public ITouchscreen Touchscreen
229        {
230            get => _touchscreen;
231        }
232
233        public IReadOnlyList<IWorker> Workers => WorkersList;
234
235        public IVideo Video
236        {
237            get
238            {
239                if (Context.Options.RecordVideoDir == null)
240                {
241                    return null;
242                }
243
244                return ForceVideo();
245            }
246            set => _video = value as Video;
247        }
248
249        internal BrowserContext OwnedContext { get; set; }
250
251        internal Dictionary<string, Delegate> Bindings { get; } = new();
252
253        internal List<Worker> WorkersList { get; } = new();
254
255        internal Page Opener => _initializer.Opener;
256
257        internal PageChannel Channel => _channel;
258
259        internal float DefaultTimeout
260        {
261            get => _defaultTimeout;
262            set
263            {
264                _defaultTimeout = value;
265                _channel.SetDefaultTimeoutNoReplyAsync(value).IgnoreException();
266            }
267        }
268
269        internal float DefaultNavigationTimeout
270        {
271            get => _defaultNavigationTimeout;
272            set
273            {
274                _defaultNavigationTimeout = value;
275                _channel.SetDefaultNavigationTimeoutNoReplyAsync(value).IgnoreException();
276            }
277        }
278
279        internal TaskCompletionSource<bool> ClosedOrCrashedTcs { get; } = new();
280
281        public IFrame Frame(string name)
282            => Frames.FirstOrDefault(f => f.Name == name);
283
284        public IFrame FrameByUrl(string urlString) => Frames.FirstOrDefault(f => Context.UrlMatches(urlString, f.Url));
285
286        public IFrame FrameByUrl(Regex urlRegex) => Frames.FirstOrDefault(f => urlRegex.IsMatch(f.Url));
287
288        public IFrame FrameByUrl(Func<string, bool> urlFunc) => Frames.FirstOrDefault(f => urlFunc(f.Url));
289
290        IFrameLocator IPage.FrameLocator(string selector) => MainFrame.FrameLocator(selector);
291
292        public Task<string> TitleAsync() => MainFrame.TitleAsync();
293
294        public Task BringToFrontAsync() => _channel.BringToFrontAsync();
295
296        public Task<IPage> OpenerAsync() => Task.FromResult<IPage>(Opener?.IsClosed == false ? Opener : null);
297
298        public Task EmulateMediaAsync(PageEmulateMediaOptions options = default)
299        {
300            var args = new Dictionary<string, object>
301            {
302                ["media"] = options?.Media,
303                ["colorScheme"] = options?.ColorScheme,
304                ["reducedMotion"] = options?.ReducedMotion,
305                ["forcedColors"] = options?.ForcedColors,
306            };
307            return _channel.EmulateMediaAsync(args);
308        }
309
310        public Task<IResponse> GotoAsync(string url, PageGotoOptions options = default)
311            => MainFrame.GotoAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout, Referer = options?.Referer });
312
313        public Task WaitForURLAsync(string url, PageWaitForURLOptions options = default)
314            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });
315
316        public Task WaitForURLAsync(Regex url, PageWaitForURLOptions options = default)
317            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });
318
319        public Task WaitForURLAsync(Func<string, bool> url, PageWaitForURLOptions options = default)
320            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });
321
322        public Task<IConsoleMessage> WaitForConsoleMessageAsync(PageWaitForConsoleMessageOptions options = default)
323            => InnerWaitForEventAsync(PageEvent.Console, null, options?.Predicate, options?.Timeout);
324
325        public Task<IFileChooser> WaitForFileChooserAsync(PageWaitForFileChooserOptions options = default)
326            => InnerWaitForEventAsync(PageEvent.FileChooser, null, options?.Predicate, options?.Timeout);
327
328        public Task<IPage> WaitForPopupAsync(PageWaitForPopupOptions options = default)
329            => InnerWaitForEventAsync(PageEvent.Popup, null, options?.Predicate, options?.Timeout);
330
331        public Task<IWebSocket> WaitForWebSocketAsync(PageWaitForWebSocketOptions options = default)
332            => InnerWaitForEventAsync(PageEvent.WebSocket, null, options?.Predicate, options?.Timeout);
333
334        public Task<IWorker> WaitForWorkerAsync(PageWaitForWorkerOptions options = default)
335            => InnerWaitForEventAsync(PageEvent.Worker, null, options?.Predicate, options?.Timeout);
336
337        public Task<IResponse> WaitForNavigationAsync(PageWaitForNavigationOptions options = default)
338            => MainFrame.WaitForNavigationAsync(new()
339            {
340                UrlString = options?.UrlString,
341                UrlRegex = options?.UrlRegex,
342                UrlFunc = options?.UrlFunc,
343                WaitUntil = options?.WaitUntil,
344                Timeout = options?.Timeout,
345            });
346
347        public Task<IResponse> RunAndWaitForNavigationAsync(Func<Task> action, PageRunAndWaitForNavigationOptions options = default)
348            => MainFrame.RunAndWaitForNavigationAsync(action, new()
349            {
350                UrlString = options?.UrlString,
351                UrlRegex = options?.UrlRegex,
352                UrlFunc = options?.UrlFunc,
353                WaitUntil = options?.WaitUntil,
354                Timeout = options?.Timeout,
355            });
356
357        public Task<IRequest> WaitForRequestAsync(string urlOrPredicate, PageWaitForRequestOptions options = default)
358            => InnerWaitForEventAsync(PageEvent.Request, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);
359
360        public Task<IRequest> WaitForRequestAsync(Regex urlOrPredicate, PageWaitForRequestOptions options = default)
361            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);
362
363        public Task<IRequest> WaitForRequestAsync(Func<IRequest, bool> urlOrPredicate, PageWaitForRequestOptions options = default)
364            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate(e), options?.Timeout);
365
366        public Task<IRequest> WaitForRequestFinishedAsync(PageWaitForRequestFinishedOptions options = default)
367            => InnerWaitForEventAsync(PageEvent.RequestFinished, null, options?.Predicate, options?.Timeout);
368
369        public Task<IResponse> WaitForResponseAsync(string urlOrPredicate, PageWaitForResponseOptions options = default)
370            => InnerWaitForEventAsync(PageEvent.Response, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);
371
372        public Task<IResponse> WaitForResponseAsync(Regex urlOrPredicate, PageWaitForResponseOptions options = default)
373            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);
374
375        public Task<IResponse> WaitForResponseAsync(Func<IResponse, bool> urlOrPredicate, PageWaitForResponseOptions options = default)
376            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate(e), options?.Timeout);
377
378        public Task<IConsoleMessage> RunAndWaitForConsoleMessageAsync(Func<Task> action, PageRunAndWaitForConsoleMessageOptions options = default)
379            => InnerWaitForEventAsync(PageEvent.Console, action, options?.Predicate, options?.Timeout);
380
381        public Task<IDownload> WaitForDownloadAsync(PageWaitForDownloadOptions options = default)
382            => InnerWaitForEventAsync(PageEvent.Download, null, options?.Predicate, options?.Timeout);
383
384        public Task<IDownload> RunAndWaitForDownloadAsync(Func<Task> action, PageRunAndWaitForDownloadOptions options = default)
385            => InnerWaitForEventAsync(PageEvent.Download, action, options?.Predicate, options?.Timeout);
386
387        public Task<IFileChooser> RunAndWaitForFileChooserAsync(Func<Task> action, PageRunAndWaitForFileChooserOptions options = default)
388            => InnerWaitForEventAsync(PageEvent.FileChooser, action, options?.Predicate, options?.Timeout);
389
390        public Task<IPage> RunAndWaitForPopupAsync(Func<Task> action, PageRunAndWaitForPopupOptions options = default)
391            => InnerWaitForEventAsync(PageEvent.Popup, action, options?.Predicate, options?.Timeout);
392
393        public Task<IRequest> RunAndWaitForRequestFinishedAsync(Func<Task> action, PageRunAndWaitForRequestFinishedOptions options = default)
394            => InnerWaitForEventAsync(PageEvent.RequestFinished, action, options?.Predicate, options?.Timeout);
395
396        public Task<IWebSocket> RunAndWaitForWebSocketAsync(Func<Task> action, PageRunAndWaitForWebSocketOptions options = default)
397            => InnerWaitForEventAsync(PageEvent.WebSocket, action, options?.Predicate, options?.Timeout);
398
399        public Task<IWorker> RunAndWaitForWorkerAsync(Func<Task> action, PageRunAndWaitForWorkerOptions options = default)
400            => InnerWaitForEventAsync(PageEvent.Worker, action, options?.Predicate, options?.Timeout);
401
402        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
403            => InnerWaitForEventAsync(PageEvent.Request, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);
404
405        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
406            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);
407
408        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Func<IRequest, bool> urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
409            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate(e), options?.Timeout);
410
411        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
412            => InnerWaitForEventAsync(PageEvent.Response, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);
413
414        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
415            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);
416
417        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Func<IResponse, bool> urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
418            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate(e), options?.Timeout);
419
420        public Task<IJSHandle> WaitForFunctionAsync(string expression, object arg = default, PageWaitForFunctionOptions options = default)
421            => MainFrame.WaitForFunctionAsync(expression, arg, new() { PollingInterval = options?.PollingInterval, Timeout = options?.Timeout });
422
423        public async Task<T> InnerWaitForEventAsync<T>(PlaywrightEvent<T> pageEvent, Func<Task> action = default, Func<T, bool> predicate = default, float? timeout = default)
424        {
425            if (pageEvent == null)
426            {
427                throw new ArgumentException("Page event is required", nameof(pageEvent));
428            }
429
430            timeout ??= _defaultTimeout;
431            using var waiter = new Waiter(this, $"page.WaitForEventAsync(\"{typeof(T)}\")");
432            waiter.RejectOnTimeout(Convert.ToInt32(timeout), $"Timeout {timeout}ms exceeded while waiting for event \"{pageEvent.Name}\"");
433
434            if (pageEvent.Name != PageEvent.Crash.Name)
435            {
436                waiter.RejectOnEvent<IPage>(this, PageEvent.Crash.Name, new("Page crashed"));
437            }
438
439            if (pageEvent.Name != PageEvent.Close.Name)
440            {
441                waiter.RejectOnEvent<IPage>(this, PageEvent.Close.Name, new("Page closed"));
442            }
443
444            var result = waiter.WaitForEventAsync(this, pageEvent.Name, predicate);
445            if (action != null)
446            {
447                await WrapApiBoundaryAsync(() => Task.WhenAll(result, action())).ConfigureAwait(false);
448            }
449
450            return await result.ConfigureAwait(false);
451        }
452
453        public async Task CloseAsync(PageCloseOptions options = default)
454        {
455            try
456            {
457                await _channel.CloseAsync(options?.RunBeforeUnload ?? false).ConfigureAwait(false);
458                if (OwnedContext != null)
459                {
460                    await OwnedContext.CloseAsync().ConfigureAwait(false);
461                }
462            }
463            catch (Exception e) when (DriverMessages.IsSafeCloseError(e))
464            {
465                // Swallow exception
466            }
467        }
468
469        public Task<T> EvaluateAsync<T>(string expression, object arg) => MainFrame.EvaluateAsync<T>(expression, arg);
470
471        public Task<JsonElement?> EvalOnSelectorAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync(selector, expression, arg);
472
473        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg = null, PageEvalOnSelectorOptions options = null)
474            => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg, new() { Strict = options?.Strict });
475
476        public ILocator Locator(string selector, PageLocatorOptions options = default)
477            => MainFrame.Locator(selector, new() { HasTextString = options?.HasTextString, HasTextRegex = options?.HasTextRegex, Has = options?.Has });
478
479        public Task<IElementHandle> QuerySelectorAsync(string selector, PageQuerySelectorOptions options = null)
480            => MainFrame.QuerySelectorAsync(selector, new() { Strict = options?.Strict });
481
482        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg);
483
484        public Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync(selector, expression, arg);
485
486        public Task<T> EvalOnSelectorAllAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync<T>(selector, expression, arg);
487
488        public Task FillAsync(string selector, string value, PageFillOptions options = default)
489            => MainFrame.FillAsync(selector, value, new() { NoWaitAfter = options?.NoWaitAfter, Timeout = options?.Timeout, Force = options?.Force, Strict = options?.Strict });
490
491        public Task SetInputFilesAsync(string selector, string files, PageSetInputFilesOptions options = default)
492            => MainFrame.SetInputFilesAsync(selector, files, Map(options));
493
494        public Task SetInputFilesAsync(string selector, IEnumerable<string> files, PageSetInputFilesOptions options = default)
495            => MainFrame.SetInputFilesAsync(selector, files, Map(options));
496
497        public Task SetInputFilesAsync(string selector, FilePayload files, PageSetInputFilesOptions options = default)
498            => MainFrame.SetInputFilesAsync(selector, files, Map(options));
499
500        public Task SetInputFilesAsync(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions options = default)
501            => MainFrame.SetInputFilesAsync(selector, files, Map(options));
502
503        public Task TypeAsync(string selector, string text, PageTypeOptions options = default)
504            => MainFrame.TypeAsync(selector, text, new()
505            {
506                Delay = options?.Delay,
507                NoWaitAfter = options?.NoWaitAfter,
508                Timeout = options?.Timeout,
509                Strict = options?.Strict,
510            });
511
512        public Task FocusAsync(string selector, PageFocusOptions options = default)
513            => MainFrame.FocusAsync(selector, new()
514            {
515                Timeout = options?.Timeout,
516                Strict = options?.Strict,
517            });
518
519        public Task HoverAsync(string selector, PageHoverOptions options = default)
520            => MainFrame.HoverAsync(
521                selector,
522                new()
523                {
524                    Position = options?.Position,
525                    Modifiers = options?.Modifiers,
526                    Force = options?.Force,
527                    Timeout = options?.Timeout,
528                    Trial = options?.Trial,
529                    Strict = options?.Strict,
530                });
531
532        public Task PressAsync(string selector, string key, PagePressOptions options = default)
533            => MainFrame.PressAsync(selector, key, new()
534            {
535                Delay = options?.Delay,
536                NoWaitAfter = options?.NoWaitAfter,
537                Timeout = options?.Timeout,
538                Strict = options?.Strict,
539            });
540
541        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, string values, PageSelectOptionOptions options = default)
542            => SelectOptionAsync(selector, new[] { values }, options);
543
544        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<string> values, PageSelectOptionOptions options = default)
545            => SelectOptionAsync(selector, values.Select(x => new SelectOptionValue() { Value = x }), options);
546
547        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IElementHandle values, PageSelectOptionOptions options = default)
548            => SelectOptionAsync(selector, new[] { values }, options);
549
550        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<IElementHandle> values, PageSelectOptionOptions options = default)
551            => MainFrame.SelectOptionAsync(selector, values, new()
552            {
553                NoWaitAfter = options?.NoWaitAfter,
554                Timeout = options?.Timeout,
555                Force = options?.Force,
556                Strict = options?.Strict,
557            });
558
559        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, SelectOptionValue values, PageSelectOptionOptions options = default)
560            => SelectOptionAsync(selector, new[] { values }, options);
561
562        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<SelectOptionValue> values, PageSelectOptionOptions options = default)
563            => MainFrame.SelectOptionAsync(selector, values, new()
564            {
565                NoWaitAfter = options?.NoWaitAfter,
566                Timeout = options?.Timeout,
567                Force = options?.Force,
568                Strict = options?.Strict,
569            });
570
571        public Task WaitForTimeoutAsync(float timeout) => MainFrame.WaitForTimeoutAsync(timeout);
572
573        public Task<IElementHandle> WaitForSelectorAsync(string selector, PageWaitForSelectorOptions options = default)
574            => MainFrame.WaitForSelectorAsync(selector, new()
575            {
576                State = options?.State,
577                Timeout = options?.Timeout,
578                Strict = options?.Strict,
579            });
580
581        public Task<JsonElement?> EvaluateAsync(string expression, object arg) => MainFrame.EvaluateAsync(expression, arg);
582
583        public async Task<byte[]> ScreenshotAsync(PageScreenshotOptions options = default)
584        {
585            options ??= new PageScreenshotOptions();
586            if (options.Type == null && !string.IsNullOrEmpty(options.Path))
587            {
588                options.Type = ElementHandle.DetermineScreenshotType(options.Path);
589            }
590
591            byte[] result = await _channel.ScreenshotAsync(
592                path: options.Path,
593                fullPage: options.FullPage,
594                clip: options.Clip,
595                omitBackground: options.OmitBackground,
596                type: options.Type,
597                quality: options.Quality,
598                mask: options.Mask,
599                animations: options.Animations,
600                caret: options.Caret,
601                scale: options.Scale,
602                timeout: options.Timeout).ConfigureAwait(false);
603
604            if (!string.IsNullOrEmpty(options.Path))
605            {
606                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);
607                File.WriteAllBytes(options.Path, result);
608            }
609
610            return result;
611        }
612
613        public Task SetContentAsync(string html, PageSetContentOptions options = default)
614            => MainFrame.SetContentAsync(html, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });
615
616        public Task<string> ContentAsync() => MainFrame.ContentAsync();
617
618        public Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
619            => _channel.SetExtraHTTPHeadersAsync(headers);
620
621        public Task<IElementHandle> QuerySelectorAsync(string selector) => MainFrame.QuerySelectorAsync(selector);
622
623        public Task<IReadOnlyList<IElementHandle>> QuerySelectorAllAsync(string selector)
624            => MainFrame.QuerySelectorAllAsync(selector);
625
626        public Task<IJSHandle> EvaluateHandleAsync(string expression, object arg) => MainFrame.EvaluateHandleAsync(expression, arg);
627
628        public Task<IElementHandle> AddScriptTagAsync(PageAddScriptTagOptions options = default)
629            => MainFrame.AddScriptTagAsync(new()
630            {
631                Url = options?.Url,
632                Path = options?.Path,
633                Content = options?.Content,
634                Type = options?.Type,
635            });
636
637        public Task<IElementHandle> AddStyleTagAsync(PageAddStyleTagOptions options = default)
638            => MainFrame.AddStyleTagAsync(new()
639            {
640                Url = options?.Url,
641                Path = options?.Path,
642                Content = options?.Content,
643            });
644
645        public Task ClickAsync(string selector, PageClickOptions options = default)
646            => MainFrame.ClickAsync(
647                selector,
648                new()
649                {
650                    Button = options?.Button,
651                    ClickCount = options?.ClickCount,
652                    Delay = options?.Delay,
653                    Position = options?.Position,
654                    Modifiers = options?.Modifiers,
655                    Force = options?.Force,
656                    NoWaitAfter = options?.NoWaitAfter,
657                    Timeout = options?.Timeout,
658                    Trial = options?.Trial,
659                    Strict = options?.Strict,
660                });
661
662        public Task DblClickAsync(string selector, PageDblClickOptions options = default)
663            => MainFrame.DblClickAsync(selector, new()
664            {
665                Delay = options?.Delay,
666                Button = options?.Button,
667                Position = options?.Position,
668                Modifiers = options?.Modifiers,
669                Timeout = options?.Timeout,
670                Force = options?.Force,
671                NoWaitAfter = options?.NoWaitAfter,
672                Trial = options?.Trial,
673                Strict = options?.Strict,
674            });
675
676        public async Task<IResponse> GoBackAsync(PageGoBackOptions options = default)
677            => (await _channel.GoBackAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
678
679        public async Task<IResponse> GoForwardAsync(PageGoForwardOptions options = default)
680            => (await _channel.GoForwardAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
681
682        public async Task<IResponse> ReloadAsync(PageReloadOptions options = default)
683            => (await _channel.ReloadAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
684
685        public Task ExposeBindingAsync(string name, Action callback, PageExposeBindingOptions options = default)
686            => InnerExposeBindingAsync(name, (Delegate)callback, options?.Handle ?? false);
687
688        public Task ExposeBindingAsync(string name, Action<BindingSource> callback)
689            => InnerExposeBindingAsync(name, (Delegate)callback);
690
691        public Task ExposeBindingAsync<T>(string name, Action<BindingSource, T> callback)
692            => InnerExposeBindingAsync(name, (Delegate)callback);
693
694        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, TResult> callback)
695            => InnerExposeBindingAsync(name, (Delegate)callback);
696
697        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, IJSHandle, TResult> callback)
698            => InnerExposeBindingAsync(name, (Delegate)callback, true);
699
700        public Task ExposeBindingAsync<T, TResult>(string name, Func<BindingSource, T, TResult> callback)
701            => InnerExposeBindingAsync(name, (Delegate)callback);
702
703        public Task ExposeBindingAsync<T1, T2, TResult>(string name, Func<BindingSource, T1, T2, TResult> callback)
704            => InnerExposeBindingAsync(name, (Delegate)callback);
705
706        public Task ExposeBindingAsync<T1, T2, T3, TResult>(string name, Func<BindingSource, T1, T2, T3, TResult> callback)
707            => InnerExposeBindingAsync(name, (Delegate)callback);
708
709        public Task ExposeBindingAsync<T1, T2, T3, T4, TResult>(string name, Func<BindingSource, T1, T2, T3, T4, TResult> callback)
710            => InnerExposeBindingAsync(name, (Delegate)callback);
711
712        public Task ExposeFunctionAsync(string name, Action callback)
713            => ExposeBindingAsync(name, (BindingSource _) => callback());
714
715        public Task ExposeFunctionAsync<T>(string name, Action<T> callback)
716            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));
717
718        public Task ExposeFunctionAsync<TResult>(string name, Func<TResult> callback)
719            => ExposeBindingAsync(name, (BindingSource _) => callback());
720
721        public Task ExposeFunctionAsync<T, TResult>(string name, Func<T, TResult> callback)
722            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));
723
724        public Task ExposeFunctionAsync<T1, T2, TResult>(string name, Func<T1, T2, TResult> callback)
725            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2) => callback(t1, t2));
726
727        public Task ExposeFunctionAsync<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> callback)
728            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3) => callback(t1, t2, t3));
729
730        public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> callback)
731            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3, T4 t4) => callback(t1, t2, t3, t4));
732
733        public async Task<byte[]> PdfAsync(PagePdfOptions options = default)
734        {
735            if (!Context.IsChromium)
736            {
737                throw new NotSupportedException("This browser doesn't support this action.");
738            }
739
740            byte[] result = await _channel.PdfAsync(
741                scale: options?.Scale,
742                displayHeaderFooter: options?.DisplayHeaderFooter,
743                headerTemplate: options?.HeaderTemplate,
744                footerTemplate: options?.FooterTemplate,
745                printBackground: options?.PrintBackground,
746                landscape: options?.Landscape,
747                pageRanges: options?.PageRanges,
748                format: options?.Format,
749                width: options?.Width,
750                height: options?.Height,
751                margin: options?.Margin,
752                preferCSSPageSize: options?.PreferCSSPageSize).ConfigureAwait(false);
753
754            if (!string.IsNullOrEmpty(options?.Path))
755            {
756                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);
757                File.WriteAllBytes(options.Path, result);
758            }
759
760            return result;
761        }
762
763        public Task AddInitScriptAsync(string script, string scriptPath)
764            => _channel.AddInitScriptAsync(ScriptsHelper.EvaluationScript(script, scriptPath));
765
766        public Task RouteAsync(string url, Action<IRoute> handler, PageRouteOptions options = null)
767            => RouteAsync(new Regex(Context.CombineUrlWithBase(url).GlobToRegex()), null, handler, options);
768
769        public Task RouteAsync(Regex url, Action<IRoute> handler, PageRouteOptions options = null)
770             => RouteAsync(url, null, handler, options);
771
772        public Task RouteAsync(Func<string, bool> url, Action<IRoute> handler, PageRouteOptions options = null)
773            => RouteAsync(null, url, handler, options);
774
775        public Task UnrouteAsync(string urlString, Action<IRoute> handler)
776            => UnrouteAsync(new Regex(Context.CombineUrlWithBase(urlString).GlobToRegex()), null, handler);
777
778        public Task UnrouteAsync(Regex urlString, Action<IRoute> handler)
779            => UnrouteAsync(urlString, null, handler);
780
781        public Task UnrouteAsync(Func<string, bool> urlFunc, Action<IRoute> handler)
782            => UnrouteAsync(null, urlFunc, handler);
783
784        public Task WaitForLoadStateAsync(LoadState? state = default, PageWaitForLoadStateOptions options = default)
785            => MainFrame.WaitForLoadStateAsync(state, new() { Timeout = options?.Timeout });
786
787        public Task SetViewportSizeAsync(int width, int height)
788        {
789            ViewportSize = new() { Width = width, Height = height };
790            return _channel.SetViewportSizeAsync(ViewportSize);
791        }
792
793        public Task SetCheckedAsync(string selector, bool checkedState, PageSetCheckedOptions options = null)
794            => checkedState ?
795            MainFrame.CheckAsync(selector, new()
796            {
797                Position = options?.Position,
798                Force = options?.Force,
799                NoWaitAfter = options?.NoWaitAfter,
800                Strict = options?.Strict,
801                Timeout = options?.Timeout,
802                Trial = options?.Trial,
803            })
804            : MainFrame.UncheckAsync(selector, new()
805            {
806                Position = options?.Position,
807                Force = options?.Force,
808                NoWaitAfter = options?.NoWaitAfter,
809                Timeout = options?.Timeout,
810                Trial = options?.Trial,
811                Strict = options?.Strict,
812            });
813
814        public Task CheckAsync(string selector, PageCheckOptions options = default)
815            => MainFrame.CheckAsync(selector, new()
816            {
817                Position = options?.Position,
818                Force = options?.Force,
819                NoWaitAfter = options?.NoWaitAfter,
820                Strict = options?.Strict,
821                Timeout = options?.Timeout,
822                Trial = options?.Trial,
823            });
824
825        public Task UncheckAsync(string selector, PageUncheckOptions options = default)
826            => MainFrame.UncheckAsync(selector, new()
827            {
828                Position = options?.Position,
829                Force = options?.Force,
830                NoWaitAfter = options?.NoWaitAfter,
831                Timeout = options?.Timeout,
832                Trial = options?.Trial,
833                Strict = options?.Strict,
834            });
835
836        public Task DispatchEventAsync(string selector, string type, object eventInit = default, PageDispatchEventOptions options = default)
837             => MainFrame.DispatchEventAsync(selector, type, eventInit, new() { Timeout = options?.Timeout, Strict = options?.Strict });
838
839        public Task<string> GetAttributeAsync(string selector, string name, PageGetAttributeOptions options = default)
840             => MainFrame.GetAttributeAsync(selector, name, new()
841             {
842                 Timeout = options?.Timeout,
843                 Strict = options?.Strict,
844             });
845
846        public Task<string> InnerHTMLAsync(string selector, PageInnerHTMLOptions options = default)
847             => MainFrame.InnerHTMLAsync(selector, new()
848             {
849                 Timeout = options?.Timeout,
850                 Strict = options?.Strict,
851             });
852
853        public Task<string> InnerTextAsync(string selector, PageInnerTextOptions options = default)
854             => MainFrame.InnerTextAsync(selector, new()
855             {
856                 Timeout = options?.Timeout,
857                 Strict = options?.Strict,
858             });
859
860        public Task<string> TextContentAsync(string selector, PageTextContentOptions options = default)
861             => MainFrame.TextContentAsync(selector, new()
862             {
863                 Timeout = options?.Timeout,
864                 Strict = options?.Strict,
865             });
866
867        public Task TapAsync(string selector, PageTapOptions options = default)
868            => MainFrame.TapAsync(
869                selector,
870                new()
871                {
872                    Modifiers = options?.Modifiers,
873                    Position = options?.Position,
874                    Force = options?.Force,
875                    NoWaitAfter = options?.NoWaitAfter,
876                    Timeout = options?.Timeout,
877                    Trial = options?.Trial,
878                    Strict = options?.Strict,
879                });
880
881        public Task<bool> IsCheckedAsync(string selector, PageIsCheckedOptions options = default)
882            => MainFrame.IsCheckedAsync(selector, new()
883            {
884                Timeout = options?.Timeout,
885                Strict = options?.Strict,
886            });
887
888        public Task<bool> IsDisabledAsync(string selector, PageIsDisabledOptions options = default)
889            => MainFrame.IsDisabledAsync(selector, new()
890            {
891                Timeout = options?.Timeout,
892                Strict = options?.Strict,
893            });
894
895        public Task<bool> IsEditableAsync(string selector, PageIsEditableOptions options = default)
896            => MainFrame.IsEditableAsync(selector, new()
897            {
898                Timeout = options?.Timeout,
899                Strict = options?.Strict,
900            });
901
902        public Task<bool> IsEnabledAsync(string selector, PageIsEnabledOptions options = default)
903            => MainFrame.IsEnabledAsync(selector, new()
904            {
905                Timeout = options?.Timeout,
906                Strict = options?.Strict,
907            });
908
909#pragma warning disable CS0612 // Type or member is obsolete
910        public Task<bool> IsHiddenAsync(string selector, PageIsHiddenOptions options = default)
911            => MainFrame.IsHiddenAsync(selector, new()
912            {
913                Timeout = options?.Timeout,
914                Strict = options?.Strict,
915            });
916
917        public Task<bool> IsVisibleAsync(string selector, PageIsVisibleOptions options = default)
918            => MainFrame.IsVisibleAsync(selector, new()
919            {
920                Timeout = options?.Timeout,
921                Strict = options?.Strict,
922            });
923#pragma warning restore CS0612 // Type or member is obsolete
924
925        public Task PauseAsync() => Context.Channel.PauseAsync();
926
927        public void SetDefaultNavigationTimeout(float timeout) => DefaultNavigationTimeout = timeout;
928
929        public void SetDefaultTimeout(float timeout) => DefaultTimeout = timeout;
930
931        public Task<string> InputValueAsync(string selector, PageInputValueOptions options = null)
932            => MainFrame.InputValueAsync(selector, new()
933            {
934                Timeout = options?.Timeout,
935                Strict = options?.Strict,
936            });
937
938        public Task DragAndDropAsync(string source, string target, PageDragAndDropOptions options = null)
939            => MainFrame.DragAndDropAsync(source, target, new()
940            {
941                Force = options?.Force,
942                NoWaitAfter = options?.NoWaitAfter,
943                Timeout = options?.Timeout,
944                Trial = options?.Trial,
945                Strict = options?.Strict,
946            });
947
948        internal void NotifyPopup(Page page) => Popup?.Invoke(this, page);
949
950        internal void OnFrameNavigated(Frame frame)
951            => FrameNavigated?.Invoke(this, frame);
952
953        internal void FireRequest(IRequest request) => Request?.Invoke(this, request);
954
955        internal void FireRequestFailed(IRequest request) => RequestFailed?.Invoke(this, request);
956
957        internal void FireRequestFinished(IRequest request) => RequestFinished?.Invoke(this, request);
958
959        internal void FireResponse(IResponse response) => Response?.Invoke(this, response);
960
961        private Task RouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler, PageRouteOptions options)
962            => RouteAsync(new()
963            {
964                Regex = urlRegex,
965                Function = urlFunc,
966                Handler = handler,
967                Times = options?.Times,
968            });
969
970        private Task RouteAsync(RouteSetting setting)
971        {
972            _routes.Insert(0, setting);
973
974            if (_routes.Count == 1)
975            {
976                return _channel.SetNetworkInterceptionEnabledAsync(true);
977            }
978
979            return Task.CompletedTask;
980        }
981
982        private Task UnrouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler = null)
983            => UnrouteAsync(new()
984            {
985                Function = urlFunc,
986                Regex = urlRegex,
987                Handler = handler,
988            });
989
990        private Task UnrouteAsync(RouteSetting setting)
991        {
992            var newRoutesList = new List<RouteSetting>();
993            newRoutesList.AddRange(_routes.Where(r =>
994                (setting.Regex != null && !(r.Regex == setting.Regex || (r.Regex.ToString() == setting.Regex.ToString() && r.Regex.Options == setting.Regex.Options))) ||
995                (setting.Function != null && r.Function != setting.Function) ||
996                (setting.Handler != null && r.Handler != setting.Handler)));
997            _routes = newRoutesList;
998
999            if (_routes.Count == 0)
1000            {
1001                return DisableInterceptionAsync();
1002            }
1003
1004            return Task.CompletedTask;
1005        }
1006
1007        internal void OnClose()
1008        {
1009            IsClosed = true;
1010            Context?.PagesList.Remove(this);
1011            RejectPendingOperations(false);
1012            Close?.Invoke(this, this);
1013        }
1014
1015        private void Channel_Crashed(object sender, EventArgs e)
1016        {
1017            RejectPendingOperations(true);
1018            Crash?.Invoke(this, this);
1019        }
1020
1021        private void Channel_BindingCall(object sender, BindingCallEventArgs e)
1022        {
1023            if (Bindings.TryGetValue(e.BindingCall.Name, out var binding))
1024            {
1025                _ = e.BindingCall.CallAsync(binding);
1026            }
1027        }
1028
1029        private void OnRoute(Route route, IRequest request)
1030        {
1031            foreach (var routeHandler in _routes.ToList())
1032            {
1033                if ((routeHandler.Regex?.IsMatch(request.Url) == true) ||
1034                    (routeHandler.Function?.Invoke(request.Url) == true))
1035                {
1036                    try
1037                    {
1038                        routeHandler.Handle(route);
1039                    }
1040                    finally
1041                    {
1042                        if (!routeHandler.IsActive())
1043                        {
1044                            _routes.Remove(routeHandler);
1045                            if (_routes.Count == 0)
1046                            {
1047                                DisableInterceptionAsync().ConfigureAwait(false);
1048                            }
1049                        }
1050                    }
1051                    return;
1052                }
1053            }
1054
1055            Context.OnRoute(route, request);
1056        }
1057
1058        internal async Task DisableInterceptionAsync()
1059        {
1060            await Channel.SetNetworkInterceptionEnabledAsync(false).ConfigureAwait(false);
1061        }
1062
1063        private void Channel_FrameDetached(object sender, IFrame args)
1064        {
1065            var frame = (Frame)args;
1066            _frames.Remove(frame);
1067            frame.IsDetached = true;
1068            frame.ParentFrame?.ChildFramesList?.Remove(frame);
1069            FrameDetached?.Invoke(this, args);
1070        }
1071
1072        private void Channel_FrameAttached(object sender, IFrame args)
1073        {
1074            var frame = (Frame)args;
1075            frame.Page = this;
1076            _frames.Add(frame);
1077            frame.ParentFrame?.ChildFramesList?.Add(frame);
1078            FrameAttached?.Invoke(this, args);
1079        }
1080
1081        private void RejectPendingOperations(bool isCrash)
1082        {
1083            foreach (var (_, waitTcs) in _waitForCancellationTcs.Where(e => e.PageEvent != (isCrash ? PageEvent.Crash : PageEvent.Close)))
1084            {
1085                waitTcs.TrySetException(new PlaywrightException(isCrash ? "Page crashed" : "Page closed"));
1086            }
1087
1088            _waitForCancellationTcs.Clear();
1089        }
1090
1091        private Task InnerExposeBindingAsync(string name, Delegate callback, bool handle = false)
1092        {
1093            if (Bindings.ContainsKey(name))
1094            {
1095                throw new PlaywrightException($"Function \"{name}\" has been already registered");
1096            }
1097
1098            Bindings.Add(name, callback);
1099
1100            return _channel.ExposeBindingAsync(name, handle);
1101        }
1102
1103        private Video ForceVideo() => _video ??= new(this, _channel.Connection);
1104
1105        private FrameSetInputFilesOptions Map(PageSetInputFilesOptions options)
1106        {
1107            if (options == null)
1108            {
1109                return null;
1110            }
1111
1112            return new()
1113            {
1114                NoWaitAfter = options.NoWaitAfter,
1115                Timeout = options.Timeout,
1116                Strict = options.Strict,
1117            };
1118        }
1119    }
1120}
1121

Source: Page.cs

/*
 * MIT License
 *
 * Copyright (c) 2020 Darío Kondratiuk
 * Copyright (c) 2020 Meir Blachman
 * Modifications copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.Playwright.Helpers;
using Microsoft.Playwright.Transport;
using Microsoft.Playwright.Transport.Channels;
using Microsoft.Playwright.Transport.Protocol;

namespace Microsoft.Playwright.Core
{
    internal partial class Page : ChannelOwnerBase, IChannelOwner<Page>, IPage
    {
        private readonly PageChannel _channel;
        private readonly List<Frame> _frames = new();
        private readonly List<(IEvent PageEvent, TaskCompletionSource<bool> WaitTcs)> _waitForCancellationTcs = new();
        private readonly object _fileChooserEventLock = new();
        private readonly IAccessibility _accessibility;
        private readonly IMouse _mouse;
        private readonly IKeyboard _keyboard;
        private readonly ITouchscreen _touchscreen;
        private readonly PageInitializer _initializer;

        private List<RouteSetting> _routes = new();
        private EventHandler<IFileChooser> _fileChooserEventHandler;
        private bool _fileChooserIntercepted;
        private Video _video;
        private float _defaultNavigationTimeout;
        private float _defaultTimeout;

        internal Page(IChannelOwner parent, string guid, PageInitializer initializer) : base(parent, guid)
        {
            Context = (BrowserContext)parent;

            _channel = new(guid, parent.Connection, this);

            MainFrame = initializer.MainFrame;
            MainFrame.Page = this;
            _frames.Add(MainFrame);
            if (initializer.ViewportSize != null)
            {
                ViewportSize = new() { Width = initializer.ViewportSize.Width, Height = initializer.ViewportSize.Height };
            }

            IsClosed = initializer.IsClosed;
            _accessibility = new Accessibility(_channel);
            _keyboard = new Keyboard(_channel);
            _touchscreen = new Touchscreen(_channel);
            _mouse = new Mouse(_channel);
            _channel.Closed += (_, _) => OnClose();
            _channel.Crashed += Channel_Crashed;
            _channel.Popup += (_, e) => Popup?.Invoke(this, e.Page);
            _channel.WebSocket += (_, e) => WebSocket?.Invoke(this, e);
            _channel.BindingCall += Channel_BindingCall;
            _channel.Route += (_, e) => OnRoute(e.Route, e.Request);
            _channel.FrameAttached += Channel_FrameAttached;
            _channel.FrameDetached += Channel_FrameDetached;
            _channel.Dialog += (_, e) =>
            {
                if (Dialog == null)
                {
                    if ("beforeunload".Equals(e.Type, StringComparison.Ordinal))
                    {
                        e.AcceptAsync(null).IgnoreException();
                    }
                    else
                    {
                        e.DismissAsync().IgnoreException();
                    }
                }
                else
                {
                    Dialog?.Invoke(this, e);
                }
            };
            _channel.Console += (_, e) => Console?.Invoke(this, e);
            _channel.DOMContentLoaded += (_, _) => DOMContentLoaded?.Invoke(this, this);
            _channel.Download += (_, e) => Download?.Invoke(this, new Download(this, e.Url, e.SuggestedFilename, e.Artifact.Object));
            _channel.PageError += (_, e) => PageError?.Invoke(this, e.ToString());
            _channel.Load += (_, _) => Load?.Invoke(this, this);
            _channel.Video += (_, e) => ForceVideo().ArtifactReady(e.Artifact);

            _channel.FileChooser += (_, e) => _fileChooserEventHandler?.Invoke(this, new FileChooser(this, e.Element.Object, e.IsMultiple));
            _channel.Worker += (_, e) =>
            {
                WorkersList.Add(e.WorkerChannel.Object);
                e.WorkerChannel.Object.Page = this;
                Worker?.Invoke(this, e.WorkerChannel.Object);
            };

            _defaultNavigationTimeout = Context.DefaultNavigationTimeout;
            _defaultTimeout = Context.DefaultTimeout;
            _initializer = initializer;

            Close += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);
            Crash += (_, _) => ClosedOrCrashedTcs.TrySetResult(true);
        }

        public event EventHandler<IConsoleMessage> Console;

        public event EventHandler<IPage> Popup;

        public event EventHandler<IRequest> Request;

        public event EventHandler<IWebSocket> WebSocket;

        public event EventHandler<IResponse> Response;

        public event EventHandler<IRequest> RequestFinished;

        public event EventHandler<IRequest> RequestFailed;

        public event EventHandler<IDialog> Dialog;

        public event EventHandler<IFrame> FrameAttached;

        public event EventHandler<IFrame> FrameDetached;

        public event EventHandler<IFrame> FrameNavigated;

        public event EventHandler<IFileChooser> FileChooser
        {
            add
            {
                lock (_fileChooserEventLock)
                {
                    _fileChooserEventHandler += value;
                    _fileChooserIntercepted = true;
                    _channel.SetFileChooserInterceptedNoReplyAsync(true).IgnoreException();
                }
            }

            remove
            {
                lock (_fileChooserEventLock)
                {
                    _fileChooserEventHandler -= value;

                    if (_fileChooserIntercepted)
                    {
                        _fileChooserIntercepted = false;
                        _channel.SetFileChooserInterceptedNoReplyAsync(false).IgnoreException();
                    }
                }
            }
        }

        public event EventHandler<IPage> Load;

        public event EventHandler<IPage> DOMContentLoaded;

        public event EventHandler<IPage> Close;

        public event EventHandler<IPage> Crash;

        public event EventHandler<string> PageError;

        public event EventHandler<IWorker> Worker;

        public event EventHandler<IDownload> Download;

        ChannelBase IChannelOwner.Channel => _channel;

        IChannel<Page> IChannelOwner<Page>.Channel => _channel;

        public bool IsClosed { get; private set; }

        IFrame IPage.MainFrame => MainFrame;

        public Frame MainFrame { get; }

        IBrowserContext IPage.Context => Context;

        public BrowserContext Context { get; set; }

        public PageViewportSizeResult ViewportSize { get; private set; }

        public IAccessibility Accessibility
        {
            get => _accessibility;
            set => throw new NotSupportedException();
        }

        public IMouse Mouse
        {
            get => _mouse;
            set => throw new NotSupportedException();
        }

        public string Url => MainFrame.Url;

        public IReadOnlyList<IFrame> Frames => _frames.AsReadOnly();

        public IKeyboard Keyboard
        {
            get => _keyboard;
        }

        public ITouchscreen Touchscreen
        {
            get => _touchscreen;
        }

        public IReadOnlyList<IWorker> Workers => WorkersList;

        public IVideo Video
        {
            get
            {
                if (Context.Options.RecordVideoDir == null)
                {
                    return null;
                }

                return ForceVideo();
            }
            set => _video = value as Video;
        }

        internal BrowserContext OwnedContext { get; set; }

        internal Dictionary<string, Delegate> Bindings { get; } = new();

        internal List<Worker> WorkersList { get; } = new();

        internal Page Opener => _initializer.Opener;

        internal PageChannel Channel => _channel;

        internal float DefaultTimeout
        {
            get => _defaultTimeout;
            set
            {
                _defaultTimeout = value;
                _channel.SetDefaultTimeoutNoReplyAsync(value).IgnoreException();
            }
        }

        internal float DefaultNavigationTimeout
        {
            get => _defaultNavigationTimeout;
            set
            {
                _defaultNavigationTimeout = value;
                _channel.SetDefaultNavigationTimeoutNoReplyAsync(value).IgnoreException();
            }
        }

        internal TaskCompletionSource<bool> ClosedOrCrashedTcs { get; } = new();

        public IFrame Frame(string name)
            => Frames.FirstOrDefault(f => f.Name == name);

        public IFrame FrameByUrl(string urlString) => Frames.FirstOrDefault(f => Context.UrlMatches(urlString, f.Url));

        public IFrame FrameByUrl(Regex urlRegex) => Frames.FirstOrDefault(f => urlRegex.IsMatch(f.Url));

        public IFrame FrameByUrl(Func<string, bool> urlFunc) => Frames.FirstOrDefault(f => urlFunc(f.Url));

        IFrameLocator IPage.FrameLocator(string selector) => MainFrame.FrameLocator(selector);

        public Task<string> TitleAsync() => MainFrame.TitleAsync();

        public Task BringToFrontAsync() => _channel.BringToFrontAsync();

        public Task<IPage> OpenerAsync() => Task.FromResult<IPage>(Opener?.IsClosed == false ? Opener : null);

        public Task EmulateMediaAsync(PageEmulateMediaOptions options = default)
        {
            var args = new Dictionary<string, object>
            {
                ["media"] = options?.Media,
                ["colorScheme"] = options?.ColorScheme,
                ["reducedMotion"] = options?.ReducedMotion,
                ["forcedColors"] = options?.ForcedColors,
            };
            return _channel.EmulateMediaAsync(args);
        }

        public Task<IResponse> GotoAsync(string url, PageGotoOptions options = default)
            => MainFrame.GotoAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout, Referer = options?.Referer });

        public Task WaitForURLAsync(string url, PageWaitForURLOptions options = default)
            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });

        public Task WaitForURLAsync(Regex url, PageWaitForURLOptions options = default)
            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });

        public Task WaitForURLAsync(Func<string, bool> url, PageWaitForURLOptions options = default)
            => MainFrame.WaitForURLAsync(url, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });

        public Task<IConsoleMessage> WaitForConsoleMessageAsync(PageWaitForConsoleMessageOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Console, null, options?.Predicate, options?.Timeout);

        public Task<IFileChooser> WaitForFileChooserAsync(PageWaitForFileChooserOptions options = default)
            => InnerWaitForEventAsync(PageEvent.FileChooser, null, options?.Predicate, options?.Timeout);

        public Task<IPage> WaitForPopupAsync(PageWaitForPopupOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Popup, null, options?.Predicate, options?.Timeout);

        public Task<IWebSocket> WaitForWebSocketAsync(PageWaitForWebSocketOptions options = default)
            => InnerWaitForEventAsync(PageEvent.WebSocket, null, options?.Predicate, options?.Timeout);

        public Task<IWorker> WaitForWorkerAsync(PageWaitForWorkerOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Worker, null, options?.Predicate, options?.Timeout);

        public Task<IResponse> WaitForNavigationAsync(PageWaitForNavigationOptions options = default)
            => MainFrame.WaitForNavigationAsync(new()
            {
                UrlString = options?.UrlString,
                UrlRegex = options?.UrlRegex,
                UrlFunc = options?.UrlFunc,
                WaitUntil = options?.WaitUntil,
                Timeout = options?.Timeout,
            });

        public Task<IResponse> RunAndWaitForNavigationAsync(Func<Task> action, PageRunAndWaitForNavigationOptions options = default)
            => MainFrame.RunAndWaitForNavigationAsync(action, new()
            {
                UrlString = options?.UrlString,
                UrlRegex = options?.UrlRegex,
                UrlFunc = options?.UrlFunc,
                WaitUntil = options?.WaitUntil,
                Timeout = options?.Timeout,
            });

        public Task<IRequest> WaitForRequestAsync(string urlOrPredicate, PageWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);

        public Task<IRequest> WaitForRequestAsync(Regex urlOrPredicate, PageWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);

        public Task<IRequest> WaitForRequestAsync(Func<IRequest, bool> urlOrPredicate, PageWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, null, e => urlOrPredicate(e), options?.Timeout);

        public Task<IRequest> WaitForRequestFinishedAsync(PageWaitForRequestFinishedOptions options = default)
            => InnerWaitForEventAsync(PageEvent.RequestFinished, null, options?.Predicate, options?.Timeout);

        public Task<IResponse> WaitForResponseAsync(string urlOrPredicate, PageWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, null, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);

        public Task<IResponse> WaitForResponseAsync(Regex urlOrPredicate, PageWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);

        public Task<IResponse> WaitForResponseAsync(Func<IResponse, bool> urlOrPredicate, PageWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, null, e => urlOrPredicate(e), options?.Timeout);

        public Task<IConsoleMessage> RunAndWaitForConsoleMessageAsync(Func<Task> action, PageRunAndWaitForConsoleMessageOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Console, action, options?.Predicate, options?.Timeout);

        public Task<IDownload> WaitForDownloadAsync(PageWaitForDownloadOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Download, null, options?.Predicate, options?.Timeout);

        public Task<IDownload> RunAndWaitForDownloadAsync(Func<Task> action, PageRunAndWaitForDownloadOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Download, action, options?.Predicate, options?.Timeout);

        public Task<IFileChooser> RunAndWaitForFileChooserAsync(Func<Task> action, PageRunAndWaitForFileChooserOptions options = default)
            => InnerWaitForEventAsync(PageEvent.FileChooser, action, options?.Predicate, options?.Timeout);

        public Task<IPage> RunAndWaitForPopupAsync(Func<Task> action, PageRunAndWaitForPopupOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Popup, action, options?.Predicate, options?.Timeout);

        public Task<IRequest> RunAndWaitForRequestFinishedAsync(Func<Task> action, PageRunAndWaitForRequestFinishedOptions options = default)
            => InnerWaitForEventAsync(PageEvent.RequestFinished, action, options?.Predicate, options?.Timeout);

        public Task<IWebSocket> RunAndWaitForWebSocketAsync(Func<Task> action, PageRunAndWaitForWebSocketOptions options = default)
            => InnerWaitForEventAsync(PageEvent.WebSocket, action, options?.Predicate, options?.Timeout);

        public Task<IWorker> RunAndWaitForWorkerAsync(Func<Task> action, PageRunAndWaitForWorkerOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Worker, action, options?.Predicate, options?.Timeout);

        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);

        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);

        public Task<IRequest> RunAndWaitForRequestAsync(Func<Task> action, Func<IRequest, bool> urlOrPredicate, PageRunAndWaitForRequestOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Request, action, e => urlOrPredicate(e), options?.Timeout);

        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, string urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, action, e => Context.UrlMatches(e.Url, urlOrPredicate), options?.Timeout);

        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Regex urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate.IsMatch(e.Url), options?.Timeout);

        public Task<IResponse> RunAndWaitForResponseAsync(Func<Task> action, Func<IResponse, bool> urlOrPredicate, PageRunAndWaitForResponseOptions options = default)
            => InnerWaitForEventAsync(PageEvent.Response, action, e => urlOrPredicate(e), options?.Timeout);

        public Task<IJSHandle> WaitForFunctionAsync(string expression, object arg = default, PageWaitForFunctionOptions options = default)
            => MainFrame.WaitForFunctionAsync(expression, arg, new() { PollingInterval = options?.PollingInterval, Timeout = options?.Timeout });

        public async Task<T> InnerWaitForEventAsync<T>(PlaywrightEvent<T> pageEvent, Func<Task> action = default, Func<T, bool> predicate = default, float? timeout = default)
        {
            if (pageEvent == null)
            {
                throw new ArgumentException("Page event is required", nameof(pageEvent));
            }

            timeout ??= _defaultTimeout;
            using var waiter = new Waiter(this, $"page.WaitForEventAsync(\"{typeof(T)}\")");
            waiter.RejectOnTimeout(Convert.ToInt32(timeout), $"Timeout {timeout}ms exceeded while waiting for event \"{pageEvent.Name}\"");

            if (pageEvent.Name != PageEvent.Crash.Name)
            {
                waiter.RejectOnEvent<IPage>(this, PageEvent.Crash.Name, new("Page crashed"));
            }

            if (pageEvent.Name != PageEvent.Close.Name)
            {
                waiter.RejectOnEvent<IPage>(this, PageEvent.Close.Name, new("Page closed"));
            }

            var result = waiter.WaitForEventAsync(this, pageEvent.Name, predicate);
            if (action != null)
            {
                await WrapApiBoundaryAsync(() => Task.WhenAll(result, action())).ConfigureAwait(false);
            }

            return await result.ConfigureAwait(false);
        }

        public async Task CloseAsync(PageCloseOptions options = default)
        {
            try
            {
                await _channel.CloseAsync(options?.RunBeforeUnload ?? false).ConfigureAwait(false);
                if (OwnedContext != null)
                {
                    await OwnedContext.CloseAsync().ConfigureAwait(false);
                }
            }
            catch (Exception e) when (DriverMessages.IsSafeCloseError(e))
            {
                // Swallow exception
            }
        }

        public Task<T> EvaluateAsync<T>(string expression, object arg) => MainFrame.EvaluateAsync<T>(expression, arg);

        public Task<JsonElement?> EvalOnSelectorAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync(selector, expression, arg);

        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg = null, PageEvalOnSelectorOptions options = null)
            => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg, new() { Strict = options?.Strict });

        public ILocator Locator(string selector, PageLocatorOptions options = default)
            => MainFrame.Locator(selector, new() { HasTextString = options?.HasTextString, HasTextRegex = options?.HasTextRegex, Has = options?.Has });

        public Task<IElementHandle> QuerySelectorAsync(string selector, PageQuerySelectorOptions options = null)
            => MainFrame.QuerySelectorAsync(selector, new() { Strict = options?.Strict });

        public Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAsync<T>(selector, expression, arg);

        public Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync(selector, expression, arg);

        public Task<T> EvalOnSelectorAllAsync<T>(string selector, string expression, object arg) => MainFrame.EvalOnSelectorAllAsync<T>(selector, expression, arg);

        public Task FillAsync(string selector, string value, PageFillOptions options = default)
            => MainFrame.FillAsync(selector, value, new() { NoWaitAfter = options?.NoWaitAfter, Timeout = options?.Timeout, Force = options?.Force, Strict = options?.Strict });

        public Task SetInputFilesAsync(string selector, string files, PageSetInputFilesOptions options = default)
            => MainFrame.SetInputFilesAsync(selector, files, Map(options));

        public Task SetInputFilesAsync(string selector, IEnumerable<string> files, PageSetInputFilesOptions options = default)
            => MainFrame.SetInputFilesAsync(selector, files, Map(options));

        public Task SetInputFilesAsync(string selector, FilePayload files, PageSetInputFilesOptions options = default)
            => MainFrame.SetInputFilesAsync(selector, files, Map(options));

        public Task SetInputFilesAsync(string selector, IEnumerable<FilePayload> files, PageSetInputFilesOptions options = default)
            => MainFrame.SetInputFilesAsync(selector, files, Map(options));

        public Task TypeAsync(string selector, string text, PageTypeOptions options = default)
            => MainFrame.TypeAsync(selector, text, new()
            {
                Delay = options?.Delay,
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task FocusAsync(string selector, PageFocusOptions options = default)
            => MainFrame.FocusAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task HoverAsync(string selector, PageHoverOptions options = default)
            => MainFrame.HoverAsync(
                selector,
                new()
                {
                    Position = options?.Position,
                    Modifiers = options?.Modifiers,
                    Force = options?.Force,
                    Timeout = options?.Timeout,
                    Trial = options?.Trial,
                    Strict = options?.Strict,
                });

        public Task PressAsync(string selector, string key, PagePressOptions options = default)
            => MainFrame.PressAsync(selector, key, new()
            {
                Delay = options?.Delay,
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, string values, PageSelectOptionOptions options = default)
            => SelectOptionAsync(selector, new[] { values }, options);

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<string> values, PageSelectOptionOptions options = default)
            => SelectOptionAsync(selector, values.Select(x => new SelectOptionValue() { Value = x }), options);

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IElementHandle values, PageSelectOptionOptions options = default)
            => SelectOptionAsync(selector, new[] { values }, options);

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<IElementHandle> values, PageSelectOptionOptions options = default)
            => MainFrame.SelectOptionAsync(selector, values, new()
            {
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Force = options?.Force,
                Strict = options?.Strict,
            });

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, SelectOptionValue values, PageSelectOptionOptions options = default)
            => SelectOptionAsync(selector, new[] { values }, options);

        public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<SelectOptionValue> values, PageSelectOptionOptions options = default)
            => MainFrame.SelectOptionAsync(selector, values, new()
            {
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Force = options?.Force,
                Strict = options?.Strict,
            });

        public Task WaitForTimeoutAsync(float timeout) => MainFrame.WaitForTimeoutAsync(timeout);

        public Task<IElementHandle> WaitForSelectorAsync(string selector, PageWaitForSelectorOptions options = default)
            => MainFrame.WaitForSelectorAsync(selector, new()
            {
                State = options?.State,
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<JsonElement?> EvaluateAsync(string expression, object arg) => MainFrame.EvaluateAsync(expression, arg);

        public async Task<byte[]> ScreenshotAsync(PageScreenshotOptions options = default)
        {
            options ??= new PageScreenshotOptions();
            if (options.Type == null && !string.IsNullOrEmpty(options.Path))
            {
                options.Type = ElementHandle.DetermineScreenshotType(options.Path);
            }

            byte[] result = await _channel.ScreenshotAsync(
                path: options.Path,
                fullPage: options.FullPage,
                clip: options.Clip,
                omitBackground: options.OmitBackground,
                type: options.Type,
                quality: options.Quality,
                mask: options.Mask,
                animations: options.Animations,
                caret: options.Caret,
                scale: options.Scale,
                timeout: options.Timeout).ConfigureAwait(false);

            if (!string.IsNullOrEmpty(options.Path))
            {
                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);
                File.WriteAllBytes(options.Path, result);
            }

            return result;
        }

        public Task SetContentAsync(string html, PageSetContentOptions options = default)
            => MainFrame.SetContentAsync(html, new() { WaitUntil = options?.WaitUntil, Timeout = options?.Timeout });

        public Task<string> ContentAsync() => MainFrame.ContentAsync();

        public Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
            => _channel.SetExtraHTTPHeadersAsync(headers);

        public Task<IElementHandle> QuerySelectorAsync(string selector) => MainFrame.QuerySelectorAsync(selector);

        public Task<IReadOnlyList<IElementHandle>> QuerySelectorAllAsync(string selector)
            => MainFrame.QuerySelectorAllAsync(selector);

        public Task<IJSHandle> EvaluateHandleAsync(string expression, object arg) => MainFrame.EvaluateHandleAsync(expression, arg);

        public Task<IElementHandle> AddScriptTagAsync(PageAddScriptTagOptions options = default)
            => MainFrame.AddScriptTagAsync(new()
            {
                Url = options?.Url,
                Path = options?.Path,
                Content = options?.Content,
                Type = options?.Type,
            });

        public Task<IElementHandle> AddStyleTagAsync(PageAddStyleTagOptions options = default)
            => MainFrame.AddStyleTagAsync(new()
            {
                Url = options?.Url,
                Path = options?.Path,
                Content = options?.Content,
            });

        public Task ClickAsync(string selector, PageClickOptions options = default)
            => MainFrame.ClickAsync(
                selector,
                new()
                {
                    Button = options?.Button,
                    ClickCount = options?.ClickCount,
                    Delay = options?.Delay,
                    Position = options?.Position,
                    Modifiers = options?.Modifiers,
                    Force = options?.Force,
                    NoWaitAfter = options?.NoWaitAfter,
                    Timeout = options?.Timeout,
                    Trial = options?.Trial,
                    Strict = options?.Strict,
                });

        public Task DblClickAsync(string selector, PageDblClickOptions options = default)
            => MainFrame.DblClickAsync(selector, new()
            {
                Delay = options?.Delay,
                Button = options?.Button,
                Position = options?.Position,
                Modifiers = options?.Modifiers,
                Timeout = options?.Timeout,
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Trial = options?.Trial,
                Strict = options?.Strict,
            });

        public async Task<IResponse> GoBackAsync(PageGoBackOptions options = default)
            => (await _channel.GoBackAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;

        public async Task<IResponse> GoForwardAsync(PageGoForwardOptions options = default)
            => (await _channel.GoForwardAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;

        public async Task<IResponse> ReloadAsync(PageReloadOptions options = default)
            => (await _channel.ReloadAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;

        public Task ExposeBindingAsync(string name, Action callback, PageExposeBindingOptions options = default)
            => InnerExposeBindingAsync(name, (Delegate)callback, options?.Handle ?? false);

        public Task ExposeBindingAsync(string name, Action<BindingSource> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<T>(string name, Action<BindingSource, T> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<TResult>(string name, Func<BindingSource, IJSHandle, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback, true);

        public Task ExposeBindingAsync<T, TResult>(string name, Func<BindingSource, T, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<T1, T2, TResult>(string name, Func<BindingSource, T1, T2, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<T1, T2, T3, TResult>(string name, Func<BindingSource, T1, T2, T3, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeBindingAsync<T1, T2, T3, T4, TResult>(string name, Func<BindingSource, T1, T2, T3, T4, TResult> callback)
            => InnerExposeBindingAsync(name, (Delegate)callback);

        public Task ExposeFunctionAsync(string name, Action callback)
            => ExposeBindingAsync(name, (BindingSource _) => callback());

        public Task ExposeFunctionAsync<T>(string name, Action<T> callback)
            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));

        public Task ExposeFunctionAsync<TResult>(string name, Func<TResult> callback)
            => ExposeBindingAsync(name, (BindingSource _) => callback());

        public Task ExposeFunctionAsync<T, TResult>(string name, Func<T, TResult> callback)
            => ExposeBindingAsync(name, (BindingSource _, T t) => callback(t));

        public Task ExposeFunctionAsync<T1, T2, TResult>(string name, Func<T1, T2, TResult> callback)
            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2) => callback(t1, t2));

        public Task ExposeFunctionAsync<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> callback)
            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3) => callback(t1, t2, t3));

        public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> callback)
            => ExposeBindingAsync(name, (BindingSource _, T1 t1, T2 t2, T3 t3, T4 t4) => callback(t1, t2, t3, t4));

        public async Task<byte[]> PdfAsync(PagePdfOptions options = default)
        {
            if (!Context.IsChromium)
            {
                throw new NotSupportedException("This browser doesn't support this action.");
            }

            byte[] result = await _channel.PdfAsync(
                scale: options?.Scale,
                displayHeaderFooter: options?.DisplayHeaderFooter,
                headerTemplate: options?.HeaderTemplate,
                footerTemplate: options?.FooterTemplate,
                printBackground: options?.PrintBackground,
                landscape: options?.Landscape,
                pageRanges: options?.PageRanges,
                format: options?.Format,
                width: options?.Width,
                height: options?.Height,
                margin: options?.Margin,
                preferCSSPageSize: options?.PreferCSSPageSize).ConfigureAwait(false);

            if (!string.IsNullOrEmpty(options?.Path))
            {
                Directory.CreateDirectory(new FileInfo(options.Path).Directory.FullName);
                File.WriteAllBytes(options.Path, result);
            }

            return result;
        }

        public Task AddInitScriptAsync(string script, string scriptPath)
            => _channel.AddInitScriptAsync(ScriptsHelper.EvaluationScript(script, scriptPath));

        public Task RouteAsync(string url, Action<IRoute> handler, PageRouteOptions options = null)
            => RouteAsync(new Regex(Context.CombineUrlWithBase(url).GlobToRegex()), null, handler, options);

        public Task RouteAsync(Regex url, Action<IRoute> handler, PageRouteOptions options = null)
             => RouteAsync(url, null, handler, options);

        public Task RouteAsync(Func<string, bool> url, Action<IRoute> handler, PageRouteOptions options = null)
            => RouteAsync(null, url, handler, options);

        public Task UnrouteAsync(string urlString, Action<IRoute> handler)
            => UnrouteAsync(new Regex(Context.CombineUrlWithBase(urlString).GlobToRegex()), null, handler);

        public Task UnrouteAsync(Regex urlString, Action<IRoute> handler)
            => UnrouteAsync(urlString, null, handler);

        public Task UnrouteAsync(Func<string, bool> urlFunc, Action<IRoute> handler)
            => UnrouteAsync(null, urlFunc, handler);

        public Task WaitForLoadStateAsync(LoadState? state = default, PageWaitForLoadStateOptions options = default)
            => MainFrame.WaitForLoadStateAsync(state, new() { Timeout = options?.Timeout });

        public Task SetViewportSizeAsync(int width, int height)
        {
            ViewportSize = new() { Width = width, Height = height };
            return _channel.SetViewportSizeAsync(ViewportSize);
        }

        public Task SetCheckedAsync(string selector, bool checkedState, PageSetCheckedOptions options = null)
            => checkedState ?
            MainFrame.CheckAsync(selector, new()
            {
                Position = options?.Position,
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Strict = options?.Strict,
                Timeout = options?.Timeout,
                Trial = options?.Trial,
            })
            : MainFrame.UncheckAsync(selector, new()
            {
                Position = options?.Position,
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Trial = options?.Trial,
                Strict = options?.Strict,
            });

        public Task CheckAsync(string selector, PageCheckOptions options = default)
            => MainFrame.CheckAsync(selector, new()
            {
                Position = options?.Position,
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Strict = options?.Strict,
                Timeout = options?.Timeout,
                Trial = options?.Trial,
            });

        public Task UncheckAsync(string selector, PageUncheckOptions options = default)
            => MainFrame.UncheckAsync(selector, new()
            {
                Position = options?.Position,
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Trial = options?.Trial,
                Strict = options?.Strict,
            });

        public Task DispatchEventAsync(string selector, string type, object eventInit = default, PageDispatchEventOptions options = default)
             => MainFrame.DispatchEventAsync(selector, type, eventInit, new() { Timeout = options?.Timeout, Strict = options?.Strict });

        public Task<string> GetAttributeAsync(string selector, string name, PageGetAttributeOptions options = default)
             => MainFrame.GetAttributeAsync(selector, name, new()
             {
                 Timeout = options?.Timeout,
                 Strict = options?.Strict,
             });

        public Task<string> InnerHTMLAsync(string selector, PageInnerHTMLOptions options = default)
             => MainFrame.InnerHTMLAsync(selector, new()
             {
                 Timeout = options?.Timeout,
                 Strict = options?.Strict,
             });

        public Task<string> InnerTextAsync(string selector, PageInnerTextOptions options = default)
             => MainFrame.InnerTextAsync(selector, new()
             {
                 Timeout = options?.Timeout,
                 Strict = options?.Strict,
             });

        public Task<string> TextContentAsync(string selector, PageTextContentOptions options = default)
             => MainFrame.TextContentAsync(selector, new()
             {
                 Timeout = options?.Timeout,
                 Strict = options?.Strict,
             });

        public Task TapAsync(string selector, PageTapOptions options = default)
            => MainFrame.TapAsync(
                selector,
                new()
                {
                    Modifiers = options?.Modifiers,
                    Position = options?.Position,
                    Force = options?.Force,
                    NoWaitAfter = options?.NoWaitAfter,
                    Timeout = options?.Timeout,
                    Trial = options?.Trial,
                    Strict = options?.Strict,
                });

        public Task<bool> IsCheckedAsync(string selector, PageIsCheckedOptions options = default)
            => MainFrame.IsCheckedAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<bool> IsDisabledAsync(string selector, PageIsDisabledOptions options = default)
            => MainFrame.IsDisabledAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<bool> IsEditableAsync(string selector, PageIsEditableOptions options = default)
            => MainFrame.IsEditableAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<bool> IsEnabledAsync(string selector, PageIsEnabledOptions options = default)
            => MainFrame.IsEnabledAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

#pragma warning disable CS0612 // Type or member is obsolete
        public Task<bool> IsHiddenAsync(string selector, PageIsHiddenOptions options = default)
            => MainFrame.IsHiddenAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task<bool> IsVisibleAsync(string selector, PageIsVisibleOptions options = default)
            => MainFrame.IsVisibleAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });
#pragma warning restore CS0612 // Type or member is obsolete

        public Task PauseAsync() => Context.Channel.PauseAsync();

        public void SetDefaultNavigationTimeout(float timeout) => DefaultNavigationTimeout = timeout;

        public void SetDefaultTimeout(float timeout) => DefaultTimeout = timeout;

        public Task<string> InputValueAsync(string selector, PageInputValueOptions options = null)
            => MainFrame.InputValueAsync(selector, new()
            {
                Timeout = options?.Timeout,
                Strict = options?.Strict,
            });

        public Task DragAndDropAsync(string source, string target, PageDragAndDropOptions options = null)
            => MainFrame.DragAndDropAsync(source, target, new()
            {
                Force = options?.Force,
                NoWaitAfter = options?.NoWaitAfter,
                Timeout = options?.Timeout,
                Trial = options?.Trial,
                Strict = options?.Strict,
            });

        internal void NotifyPopup(Page page) => Popup?.Invoke(this, page);

        internal void OnFrameNavigated(Frame frame)
            => FrameNavigated?.Invoke(this, frame);

        internal void FireRequest(IRequest request) => Request?.Invoke(this, request);

        internal void FireRequestFailed(IRequest request) => RequestFailed?.Invoke(this, request);

        internal void FireRequestFinished(IRequest request) => RequestFinished?.Invoke(this, request);

        internal void FireResponse(IResponse response) => Response?.Invoke(this, response);

        private Task RouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler, PageRouteOptions options)
            => RouteAsync(new()
            {
                Regex = urlRegex,
                Function = urlFunc,
                Handler = handler,
                Times = options?.Times,
            });

        private Task RouteAsync(RouteSetting setting)
        {
            _routes.Insert(0, setting);

            if (_routes.Count == 1)
            {
                return _channel.SetNetworkInterceptionEnabledAsync(true);
            }

            return Task.CompletedTask;
        }

        private Task UnrouteAsync(Regex urlRegex, Func<string, bool> urlFunc, Action<IRoute> handler = null)
            => UnrouteAsync(new()
            {
                Function = urlFunc,
                Regex = urlRegex,
                Handler = handler,
            });

        private Task UnrouteAsync(RouteSetting setting)
        {
            var newRoutesList = new List<RouteSetting>();
            newRoutesList.AddRange(_routes.Where(r =>
                (setting.Regex != null && !(r.Regex == setting.Regex || (r.Regex.ToString() == setting.Regex.ToString() && r.Regex.Options == setting.Regex.Options))) ||
                (setting.Function != null && r.Function != setting.Function) ||
                (setting.Handler != null && r.Handler != setting.Handler)));
            _routes = newRoutesList;

            if (_routes.Count == 0)
            {
                return DisableInterceptionAsync();
            }

            return Task.CompletedTask;
        }

        internal void OnClose()
        {
            IsClosed = true;
            Context?.PagesList.Remove(this);
            RejectPendingOperations(false);
            Close?.Invoke(this, this);
        }

        private void Channel_Crashed(object sender, EventArgs e)
        {
            RejectPendingOperations(true);
            Crash?.Invoke(this, this);
        }

        private void Channel_BindingCall(object sender, BindingCallEventArgs e)
        {
            if (Bindings.TryGetValue(e.BindingCall.Name, out var binding))
            {
                _ = e.BindingCall.CallAsync(binding);
            }
        }

        private void OnRoute(Route route, IRequest request)
        {
            foreach (var routeHandler in _routes.ToList())
            {
                if ((routeHandler.Regex?.IsMatch(request.Url) == true) ||
                    (routeHandler.Function?.Invoke(request.Url) == true))
                {
                    try
                    {
                        routeHandler.Handle(route);
                    }
                    finally
                    {
                        if (!routeHandler.IsActive())
                        {
                            _routes.Remove(routeHandler);
                            if (_routes.Count == 0)
                            {
                                DisableInterceptionAsync().ConfigureAwait(false);
                            }
                        }
                    }
                    return;
                }
            }

            Context.OnRoute(route, request);
        }

        internal async Task DisableInterceptionAsync()
        {
            await Channel.SetNetworkInterceptionEnabledAsync(false).ConfigureAwait(false);
        }

        private void Channel_FrameDetached(object sender, IFrame args)
        {
            var frame = (Frame)args;
            _frames.Remove(frame);
            frame.IsDetached = true;
            frame.ParentFrame?.ChildFramesList?.Remove(frame);
            FrameDetached?.Invoke(this, args);
        }

        private void Channel_FrameAttached(object sender, IFrame args)
        {
            var frame = (Frame)args;
            frame.Page = this;
            _frames.Add(frame);
            frame.ParentFrame?.ChildFramesList?.Add(frame);
            FrameAttached?.Invoke(this, args);
        }

        private void RejectPendingOperations(bool isCrash)
        {
            foreach (var (_, waitTcs) in _waitForCancellationTcs.Where(e => e.PageEvent != (isCrash ? PageEvent.Crash : PageEvent.Close)))
            {
                waitTcs.TrySetException(new PlaywrightException(isCrash ? "Page crashed" : "Page closed"));
            }

            _waitForCancellationTcs.Clear();
        }

        private Task InnerExposeBindingAsync(string name, Delegate callback, bool handle = false)
        {
            if (Bindings.ContainsKey(name))
            {
                throw new PlaywrightException($"Function \"{name}\" has been already registered");
            }

            Bindings.Add(name, callback);

            return _channel.ExposeBindingAsync(name, handle);
        }

        private Video ForceVideo() => _video ??= new(this, _channel.Connection);

        private FrameSetInputFilesOptions Map(PageSetInputFilesOptions options)
        {
            if (options == null)
            {
                return null;
            }

            return new()
            {
                NoWaitAfter = options.NoWaitAfter,
                Timeout = options.Timeout,
                Strict = options.Strict,
            };
        }
    }
}