playwright-ruby-client 0.6.0 → 0.6.1

data/lib/playwright_api/browser_type.rb

@@ -1,58 +1,10 @@
 module Playwright
   # BrowserType provides methods to launch a specific browser instance or connect to an existing one. The following is a
   # typical example of using Playwright to drive automation:
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   // other actions...
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType chromium = playwright.chromium();
-  #       Browser browser = chromium.launch();
-  #       Page page = browser.newPage();
-  #       page.navigate("https://example.com");
-  #       // other actions...
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("https://example.com")
-  #     # other actions...
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
   # from playwright.sync_api import sync_playwright
-  # 
+  #
   # def run(playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
@@ -60,29 +12,10 @@ module Playwright
   #     page.goto("https://example.com")
   #     # other actions...
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
-  # ```csharp
-  # using Microsoft.Playwright;
-  # using System.Threading.Tasks;
-  # 
-  # class BrowserTypeExamples
-  # {
-  #     public static async Task Run()
-  #     {
-  #         using var playwright = await Playwright.CreateAsync();
-  #         var chromium = playwright.Chromium;
-  #         var browser = await chromium.LaunchAsync();
-  #         var page = await browser.NewPageAsync();
-  #         await page.GoToAsync("https://www.bing.com");
-  #         // other actions
-  #         await browser.CloseAsync();
-  #     }
-  # }
-  # ```
   class BrowserType < PlaywrightApi
 
     # This methods attaches Playwright to an existing browser instance.
@@ -91,9 +24,9 @@ module Playwright
     end
 
     # This methods attaches Playwright to an existing browser instance using the Chrome DevTools Protocol.
-    # 
+    #
     # The default browser context is accessible via [`method: Browser.contexts`].
-    # 
+    #
     # > NOTE: Connecting over the Chrome DevTools Protocol is only supported for Chromium-based browsers.
     def connect_over_cdp(
           endpointURL,
@@ -110,38 +43,15 @@ module Playwright
     end
 
     # Returns the browser instance.
-    # 
+    #
     # You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
-    # 
     #
-    # ```js
-    # const browser = await chromium.launch({  // Or 'firefox' or 'webkit'.
-    #   ignoreDefaultArgs: ['--mute-audio']
-    # });
-    # ```
-    # 
-    # ```java
-    # // Or "firefox" or "webkit".
-    # Browser browser = chromium.launch(new BrowserType.LaunchOptions()
-    #   .setIgnoreDefaultArgs(Arrays.asList("--mute-audio")));
-    # ```
-    # 
-    # ```python async
-    # browser = await playwright.chromium.launch( # or "firefox" or "webkit".
-    #     ignore_default_args=["--mute-audio"]
-    # )
-    # ```
-    # 
     # ```python sync
     # browser = playwright.chromium.launch( # or "firefox" or "webkit".
     #     ignore_default_args=["--mute-audio"]
     # )
     # ```
-    # 
-    # ```csharp
-    # var browser = await playwright.Chromium.LaunchAsync(ignoreDefaultArgs: new[] { "--mute-audio" })
-    # ```
-    # 
+    #
     # > **Chromium-only** Playwright can also be used to control the Google Chrome or Microsoft Edge browsers, but it works
     # best with the version of Chromium it is bundled with. There is no guarantee it will work with any other version. Use
     # `executablePath` option with extreme caution.
@@ -179,7 +89,7 @@ module Playwright
     end
 
     # Returns the persistent browser context instance.
-    # 
+    #
     # Launches browser that uses persistent storage located at `userDataDir` and returns the only context. Closing this
     # context will automatically close the browser.
     def launch_persistent_context(
@@ -233,20 +143,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/cdp_session.rb

@@ -1,39 +1,16 @@
 module Playwright
   # - extends: [EventEmitter]
-  # 
+  #
   # The `CDPSession` instances are used to talk raw Chrome Devtools Protocol:
   # - protocol methods can be called with `session.send` method.
   # - protocol events can be subscribed to with `session.on` method.
-  # 
+  #
   # Useful links:
   # - Documentation on DevTools Protocol can be found here:
   #   [DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/).
   # - Getting Started with DevTools Protocol:
   #   https://github.com/aslushnikov/getting-started-with-cdp/blob/master/README.md
-  # 
   #
-  # ```js
-  # const client = await page.context().newCDPSession(page);
-  # await client.send('Animation.enable');
-  # client.on('Animation.animationCreated', () => console.log('Animation created!'));
-  # const response = await client.send('Animation.getPlaybackRate');
-  # console.log('playback rate is ' + response.playbackRate);
-  # await client.send('Animation.setPlaybackRate', {
-  #   playbackRate: response.playbackRate / 2
-  # });
-  # ```
-  # 
-  # ```python async
-  # client = await page.context().new_cdp_session(page)
-  # await client.send("animation.enable")
-  # client.on("animation.animation_created", lambda: print("animation created!"))
-  # response = await client.send("animation.get_playback_rate")
-  # print("playback rate is " + response["playback_rate"])
-  # await client.send("animation.set_playback_rate", {
-  #     playback_rate: response["playback_rate"] / 2
-  # })
-  # ```
-  # 
   # ```python sync
   # client = page.context().new_cdp_session(page)
   # client.send("animation.enable")

data/lib/playwright_api/console_message.rb

@@ -25,20 +25,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/dialog.rb

@@ -1,73 +1,15 @@
 module Playwright
   # `Dialog` objects are dispatched by page via the [`event: Page.dialog`] event.
-  # 
+  #
   # An example of using `Dialog` class:
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   page.on('dialog', async dialog => {
-  #     console.log(dialog.message());
-  #     await dialog.dismiss();
-  #   });
-  #   await page.evaluate(() => alert('1'));
-  #   await browser.close();
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType chromium = playwright.chromium();
-  #       Browser browser = chromium.launch();
-  #       Page page = browser.newPage();
-  #       page.onDialog(dialog -> {
-  #         System.out.println(dialog.message());
-  #         dialog.dismiss();
-  #       });
-  #       page.evaluate("alert('1')");
-  #       browser.close();
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def handle_dialog(dialog):
-  #     print(dialog.message)
-  #     await dialog.dismiss()
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     page.on("dialog", handle_dialog)
-  #     page.evaluate("alert('1')")
-  #     await browser.close()
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
   # from playwright.sync_api import sync_playwright
-  # 
+  #
   # def handle_dialog(dialog):
   #     print(dialog.message)
   #     dialog.dismiss()
-  # 
+  #
   # def run(playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
@@ -75,34 +17,11 @@ module Playwright
   #     page.on("dialog", handle_dialog)
   #     page.evaluate("alert('1')")
   #     browser.close()
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
-  # ```csharp
-  # using Microsoft.Playwright;
-  # using System.Threading.Tasks;
-  # 
-  # class DialogExample
-  # {
-  #     public static async Task Run()
-  #     {
-  #         using var playwright = await Playwright.CreateAsync();
-  #         await using var browser = await playwright.Chromium.LaunchAsync();
-  #         var page = await browser.NewPageAsync();
-  # 
-  #         page.Dialog += async (_, dialog) =>
-  #         {
-  #             System.Console.WriteLine(dialog.Message);
-  #             await dialog.DismissAsync();
-  #         };
-  # 
-  #         await page.EvaluateAsync("alert('1');");
-  #     }
-  # }
-  # ```
-  # 
+  #
   # > NOTE: Dialogs are dismissed automatically, unless there is a [`event: Page.dialog`] listener. When listener is
   # present, it **must** either [`method: Dialog.accept`] or [`method: Dialog.dismiss`] the dialog - otherwise the page will
   # [freeze](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop#never_blocking) waiting for the dialog, and
@@ -141,20 +60,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy

data/lib/playwright_api/element_handle.rb

@@ -2,64 +2,13 @@ require_relative './js_handle.rb'
 
 module Playwright
   # - extends: `JSHandle`
-  # 
+  #
   # ElementHandle represents an in-page DOM element. ElementHandles can be created with the [`method: Page.querySelector`]
   # method.
-  # 
   #
-  # ```js
-  # const { chromium } = require('playwright');  // Or 'firefox' or 'webkit'.
-  # 
-  # (async () => {
-  #   const browser = await chromium.launch();
-  #   const page = await browser.newPage();
-  #   await page.goto('https://example.com');
-  #   const hrefElement = await page.$('a');
-  #   await hrefElement.click();
-  #   // ...
-  # })();
-  # ```
-  # 
-  # ```java
-  # import com.microsoft.playwright.*;
-  # 
-  # public class Example {
-  #   public static void main(String[] args) {
-  #     try (Playwright playwright = Playwright.create()) {
-  #       BrowserType chromium = playwright.chromium();
-  #       Browser browser = chromium.launch();
-  #       Page page = browser.newPage();
-  #       page.navigate("https://example.com");
-  #       ElementHandle hrefElement = page.querySelector("a");
-  #       hrefElement.click();
-  #       // ...
-  #     }
-  #   }
-  # }
-  # ```
-  # 
-  # ```python async
-  # import asyncio
-  # from playwright.async_api import async_playwright
-  # 
-  # async def run(playwright):
-  #     chromium = playwright.chromium
-  #     browser = await chromium.launch()
-  #     page = await browser.new_page()
-  #     await page.goto("https://example.com")
-  #     href_element = await page.query_selector("a")
-  #     await href_element.click()
-  #     # ...
-  # 
-  # async def main():
-  #     async with async_playwright() as playwright:
-  #         await run(playwright)
-  # asyncio.run(main())
-  # ```
-  # 
   # ```python sync
   # from playwright.sync_api import sync_playwright
-  # 
+  #
   # def run(playwright):
   #     chromium = playwright.chromium
   #     browser = chromium.launch()
@@ -68,74 +17,35 @@ module Playwright
   #     href_element = page.query_selector("a")
   #     href_element.click()
   #     # ...
-  # 
+  #
   # with sync_playwright() as playwright:
   #     run(playwright)
   # ```
-  # 
-  # ```csharp
-  # using Microsoft.Playwright;
-  # using System.Threading.Tasks;
-  # 
-  # class HandleExamples
-  # {
-  #     public static async Task Run()
-  #     {
-  #         using var playwright = await Playwright.CreateAsync();
-  #         var browser = await playwright.Chromium.LaunchAsync(headless: false);
-  #         var page = await browser.NewPageAsync();
-  #         await page.GotoAsync("https://www.bing.com");
-  #         var handle = await page.QuerySelectorAsync("a");
-  #         await handle.ClickAsync();
-  #     }
-  # }
-  # ```
-  # 
+  #
   # ElementHandle prevents DOM element from garbage collection unless the handle is disposed with
   # [`method: JSHandle.dispose`]. ElementHandles are auto-disposed when their origin frame gets navigated.
-  # 
+  #
   # ElementHandle instances can be used as an argument in [`method: Page.evalOnSelector`] and [`method: Page.evaluate`]
   # methods.
   class ElementHandle < JSHandle
 
     # This method returns the bounding box of the element, or `null` if the element is not visible. The bounding box is
     # calculated relative to the main frame viewport - which is usually the same as the browser window.
-    # 
+    #
     # Scrolling affects the returned bonding box, similarly to
     # [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect). That
     # means `x` and/or `y` may be negative.
-    # 
+    #
     # Elements from child frames return the bounding box relative to the main frame, unlike the
     # [Element.getBoundingClientRect](https://developer.mozilla.org/en-US/docs/Web/API/Element/getBoundingClientRect).
-    # 
+    #
     # Assuming the page is static, it is safe to use bounding box coordinates to perform input. For example, the following
     # snippet should click the center of the element.
-    # 
     #
-    # ```js
-    # const box = await elementHandle.boundingBox();
-    # await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
-    # ```
-    # 
-    # ```java
-    # BoundingBox box = elementHandle.boundingBox();
-    # page.mouse().click(box.x + box.width / 2, box.y + box.height / 2);
-    # ```
-    # 
-    # ```python async
-    # box = await element_handle.bounding_box()
-    # await page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
-    # ```
-    # 
     # ```python sync
     # box = element_handle.bounding_box()
     # page.mouse.click(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
     # ```
-    # 
-    # ```csharp
-    # var box = await elementHandle.BoundingBoxAsync();
-    # await page.Mouse.ClickAsync(box.X + box.Width / 2, box.Y + box.Height / 2);
-    # ```
     def bounding_box
       wrap_impl(@impl.bounding_box)
     end
@@ -148,9 +58,9 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 1. Ensure that the element is now checked. If not, this method throws.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
     def check(
@@ -167,9 +77,9 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
     def click(
@@ -196,12 +106,12 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to double click in the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set. Note that if the
     #    first click of the `dblclick()` triggers a navigation event, this method will throw.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: `elementHandle.dblclick()` dispatches two `click` events and a single `dblclick` event.
     def dblclick(
           button: nil,
@@ -218,31 +128,14 @@ module Playwright
     # The snippet below dispatches the `click` event on the element. Regardless of the visibility state of the element,
     # `click` is dispatched. This is equivalent to calling
     # [element.click()](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/click).
-    # 
     #
-    # ```js
-    # await elementHandle.dispatchEvent('click');
-    # ```
-    # 
-    # ```java
-    # elementHandle.dispatchEvent("click");
-    # ```
-    # 
-    # ```python async
-    # await element_handle.dispatch_event("click")
-    # ```
-    # 
     # ```python sync
     # element_handle.dispatch_event("click")
     # ```
-    # 
-    # ```csharp
-    # await elementHandle.DispatchEventAsync("click");
-    # ```
-    # 
+    #
     # Under the hood, it creates an instance of an event based on the given `type`, initializes it with `eventInit` properties
     # and dispatches it on the element. Events are `composed`, `cancelable` and bubble by default.
-    # 
+    #
     # Since `eventInit` is event-specific, please refer to the events documentation for the lists of initial properties:
     # - [DragEvent](https://developer.mozilla.org/en-US/docs/Web/API/DragEvent/DragEvent)
     # - [FocusEvent](https://developer.mozilla.org/en-US/docs/Web/API/FocusEvent/FocusEvent)
@@ -251,146 +144,71 @@ module Playwright
     # - [PointerEvent](https://developer.mozilla.org/en-US/docs/Web/API/PointerEvent/PointerEvent)
     # - [TouchEvent](https://developer.mozilla.org/en-US/docs/Web/API/TouchEvent/TouchEvent)
     # - [Event](https://developer.mozilla.org/en-US/docs/Web/API/Event/Event)
-    # 
+    #
     # You can also specify `JSHandle` as the property value if you want live objects to be passed into the event:
-    # 
     #
-    # ```js
-    # // Note you can only create DataTransfer in Chromium and Firefox
-    # const dataTransfer = await page.evaluateHandle(() => new DataTransfer());
-    # await elementHandle.dispatchEvent('dragstart', { dataTransfer });
-    # ```
-    # 
-    # ```java
-    # // Note you can only create DataTransfer in Chromium and Firefox
-    # JSHandle dataTransfer = page.evaluateHandle("() => new DataTransfer()");
-    # Map<String, Object> arg = new HashMap<>();
-    # arg.put("dataTransfer", dataTransfer);
-    # elementHandle.dispatchEvent("dragstart", arg);
-    # ```
-    # 
-    # ```python async
-    # # note you can only create data_transfer in chromium and firefox
-    # data_transfer = await page.evaluate_handle("new DataTransfer()")
-    # await element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
-    # ```
-    # 
     # ```python sync
     # # note you can only create data_transfer in chromium and firefox
     # data_transfer = page.evaluate_handle("new DataTransfer()")
     # element_handle.dispatch_event("#source", "dragstart", {"dataTransfer": data_transfer})
     # ```
-    # 
-    # ```csharp
-    # var handle = await page.EvaluateHandleAsync("() => new DataTransfer()");
-    # await handle.AsElement.DispatchEventAsync("dragstart", new Dictionary<string, object>
-    # {
-    #     { "dataTransfer", dataTransfer }
-    # });
-    # ```
     def dispatch_event(type, eventInit: nil)
       wrap_impl(@impl.dispatch_event(unwrap_impl(type), eventInit: unwrap_impl(eventInit)))
     end
 
     # Returns the return value of `expression`.
-    # 
+    #
     # The method finds an element matching the specified selector in the `ElementHandle`s subtree and passes it as a first
     # argument to `expression`. See [Working with selectors](./selectors.md) for more details. If no elements match the
     # selector, the method throws an error.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelector`] would wait for the promise to resolve
     # and return its value.
-    # 
+    #
     # Examples:
-    # 
     #
-    # ```js
-    # const tweetHandle = await page.$('.tweet');
-    # expect(await tweetHandle.$eval('.like', node => node.innerText)).toBe('100');
-    # expect(await tweetHandle.$eval('.retweets', node => node.innerText)).toBe('10');
-    # ```
-    # 
-    # ```java
-    # ElementHandle tweetHandle = page.querySelector(".tweet");
-    # assertEquals("100", tweetHandle.evalOnSelector(".like", "node => node.innerText"));
-    # assertEquals("10", tweetHandle.evalOnSelector(".retweets", "node => node.innerText"));
-    # ```
-    # 
-    # ```python async
-    # tweet_handle = await page.query_selector(".tweet")
-    # assert await tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
-    # assert await tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
-    # ```
-    # 
     # ```python sync
     # tweet_handle = page.query_selector(".tweet")
     # assert tweet_handle.eval_on_selector(".like", "node => node.innerText") == "100"
     # assert tweet_handle.eval_on_selector(".retweets", "node => node.innerText") = "10"
     # ```
-    # 
-    # ```csharp
-    # var tweetHandle = await page.QuerySelectorAsync(".tweet");
-    # Assert.Equals("100", await tweetHandle.EvalOnSelectorAsync(".like", "node => node.innerText"));
-    # Assert.Equals("10", await tweetHandle.EvalOnSelectorAsync(".retweets", "node => node.innerText"));
-    # ```
     def eval_on_selector(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # Returns the return value of `expression`.
-    # 
+    #
     # The method finds all elements matching the specified selector in the `ElementHandle`'s subtree and passes an array of
     # matched elements as a first argument to `expression`. See [Working with selectors](./selectors.md) for more details.
-    # 
+    #
     # If `expression` returns a [Promise], then [`method: ElementHandle.evalOnSelectorAll`] would wait for the promise to
     # resolve and return its value.
-    # 
+    #
     # Examples:
-    # 
+    #
     # ```html
     # <div class="feed">
     #   <div class="tweet">Hello!</div>
     #   <div class="tweet">Hi!</div>
     # </div>
     # ```
-    # 
     #
-    # ```js
-    # const feedHandle = await page.$('.feed');
-    # expect(await feedHandle.$$eval('.tweet', nodes => nodes.map(n => n.innerText))).toEqual(['Hello!', 'Hi!']);
-    # ```
-    # 
-    # ```java
-    # ElementHandle feedHandle = page.querySelector(".feed");
-    # assertEquals(Arrays.asList("Hello!", "Hi!"), feedHandle.evalOnSelectorAll(".tweet", "nodes => nodes.map(n => n.innerText)"));
-    # ```
-    # 
-    # ```python async
-    # feed_handle = await page.query_selector(".feed")
-    # assert await feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
-    # ```
-    # 
     # ```python sync
     # feed_handle = page.query_selector(".feed")
     # assert feed_handle.eval_on_selector_all(".tweet", "nodes => nodes.map(n => n.innerText)") == ["hello!", "hi!"]
     # ```
-    # 
-    # ```csharp
-    # var feedHandle = await page.QuerySelectorAsync(".feed");
-    # Assert.Equals(new [] { "Hello!", "Hi!" }, await feedHandle.EvalOnSelectorAllAsync<string[]>(".tweet", "nodes => nodes.map(n => n.innerText)"));
-    # ```
     def eval_on_selector_all(selector, expression, arg: nil)
       wrap_impl(@impl.eval_on_selector_all(unwrap_impl(selector), unwrap_impl(expression), arg: unwrap_impl(arg)))
     end
 
     # This method waits for [actionability](./actionability.md) checks, focuses the element, fills it and triggers an `input`
     # event after filling. Note that you can pass an empty string to clear the input field.
-    # 
+    #
     # If the target element is not an `<input>`, `<textarea>` or `[contenteditable]` element, this method throws an error.
     # However, if the element is inside the `<label>` element that has an associated
     # [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be filled
     # instead.
-    # 
+    #
     # To send fine-grained keyboard events, use [`method: ElementHandle.type`].
     def fill(value, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.fill(unwrap_impl(value), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
@@ -412,9 +230,9 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.mouse`] to hover over the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
     def hover(
@@ -472,21 +290,21 @@ module Playwright
     end
 
     # Focuses the element, and then uses [`method: Keyboard.down`] and [`method: Keyboard.up`].
-    # 
+    #
     # `key` can specify the intended [keyboardEvent.key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key)
     # value or a single character to generate the text for. A superset of the `key` values can be found
     # [here](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values). Examples of the keys are:
-    # 
+    #
     # `F1` - `F12`, `Digit0`- `Digit9`, `KeyA`- `KeyZ`, `Backquote`, `Minus`, `Equal`, `Backslash`, `Backspace`, `Tab`,
     # `Delete`, `Escape`, `ArrowDown`, `End`, `Enter`, `Home`, `Insert`, `PageDown`, `PageUp`, `ArrowRight`, `ArrowUp`, etc.
-    # 
+    #
     # Following modification shortcuts are also supported: `Shift`, `Control`, `Alt`, `Meta`, `ShiftLeft`.
-    # 
+    #
     # Holding down `Shift` will type the text that corresponds to the `key` in the upper case.
-    # 
+    #
     # If `key` is a single character, it is case-sensitive, so the values `a` and `A` will generate different respective
     # texts.
-    # 
+    #
     # Shortcuts such as `key: "Control+o"` or `key: "Control+Shift+T"` are supported as well. When specified with the
     # modifier, modifier is pressed and being held while the subsequent key is being pressed.
     def press(key, delay: nil, noWaitAfter: nil, timeout: nil)
@@ -506,7 +324,7 @@ module Playwright
     end
 
     # Returns the buffer with the captured screenshot.
-    # 
+    #
     # This method waits for the [actionability](./actionability.md) checks, then scrolls element into view before taking a
     # screenshot. If the element is detached from DOM, the method throws an error.
     def screenshot(
@@ -521,7 +339,7 @@ module Playwright
     # This method waits for [actionability](./actionability.md) checks, then tries to scroll element into view, unless it is
     # completely visible as defined by
     # [IntersectionObserver](https://developer.mozilla.org/en-US/docs/Web/API/Intersection_Observer_API)'s `ratio`.
-    # 
+    #
     # Throws when `elementHandle` does not point to an element
     # [connected](https://developer.mozilla.org/en-US/docs/Web/API/Node/isConnected) to a Document or a ShadowRoot.
     def scroll_into_view_if_needed(timeout: nil)
@@ -530,45 +348,15 @@ module Playwright
 
     # This method waits for [actionability](./actionability.md) checks, waits until all specified options are present in the
     # `<select>` element and selects these options.
-    # 
+    #
     # If the target element is not a `<select>` element, this method throws an error. However, if the element is inside the
     # `<label>` element that has an associated
     # [control](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLabelElement/control), the control will be used instead.
-    # 
+    #
     # Returns the array of option values that have been successfully selected.
-    # 
+    #
     # Triggers a `change` and `input` event once all the provided options have been selected.
-    # 
-    #
-    # ```js
-    # // single selection matching the value
-    # handle.selectOption('blue');
-    # 
-    # // single selection matching the label
-    # handle.selectOption({ label: 'Blue' });
-    # 
-    # // multiple selection
-    # handle.selectOption(['red', 'green', 'blue']);
-    # ```
-    # 
-    # ```java
-    # // single selection matching the value
-    # handle.selectOption("blue");
-    # // single selection matching the label
-    # handle.selectOption(new SelectOption().setLabel("Blue"));
-    # // multiple selection
-    # handle.selectOption(new String[] {"red", "green", "blue"});
-    # ```
-    # 
-    # ```python async
-    # # single selection matching the value
-    # await handle.select_option("blue")
-    # # single selection matching the label
-    # await handle.select_option(label="blue")
-    # # multiple selection
-    # await handle.select_option(value=["red", "green", "blue"])
-    # ```
-    # 
+    #
     # ```python sync
     # # single selection matching the value
     # handle.select_option("blue")
@@ -577,7 +365,7 @@ module Playwright
     # # multiple selection
     # handle.select_option(value=["red", "green", "blue"])
     # ```
-    # 
+    #
     # ```python sync
     # # single selection matching the value
     # handle.select_option("blue")
@@ -588,20 +376,6 @@ module Playwright
     # # multiple selection for blue, red and second option
     # handle.select_option(value="blue", { index: 2 }, "red")
     # ```
-    # 
-    # ```csharp
-    # // single selection matching the value
-    # await handle.SelectOptionAsync(new[] { "blue" });
-    # // single selection matching the label
-    # await handle.SelectOptionAsync(new[] { new SelectOptionValue() { Label = "blue" } });
-    # // multiple selection
-    # await handle.SelectOptionAsync(new[] { "red", "green", "blue" });
-    # // multiple selection for blue, red and second option
-    # await handle.SelectOptionAsync(new[] {
-    #     new SelectOptionValue() { Label = "blue" },
-    #     new SelectOptionValue() { Index = 2 },
-    #     new SelectOptionValue() { Value = "red" }});
-    # ```
     def select_option(
           element: nil,
           index: nil,
@@ -620,7 +394,7 @@ module Playwright
 
     # This method expects `elementHandle` to point to an
     # [input element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input).
-    # 
+    #
     # Sets the value of the file input to these file paths or files. If some of the `filePaths` are relative paths, then they
     # are resolved relative to the the current working directory. For empty array, clears the selected files.
     def set_input_files(files, noWaitAfter: nil, timeout: nil)
@@ -633,12 +407,12 @@ module Playwright
     # 1. Scroll the element into view if needed.
     # 1. Use [`property: Page.touchscreen`] to tap the center of the element, or the specified `position`.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
-    # 
+    #
     # > NOTE: `elementHandle.tap()` requires that the `hasTouch` option of the browser context be set to true.
     def tap_point(
           force: nil,
@@ -656,67 +430,21 @@ module Playwright
     end
 
     # Focuses the element, and then sends a `keydown`, `keypress`/`input`, and `keyup` event for each character in the text.
-    # 
+    #
     # To press a special key, like `Control` or `ArrowDown`, use [`method: ElementHandle.press`].
-    # 
     #
-    # ```js
-    # await elementHandle.type('Hello'); // Types instantly
-    # await elementHandle.type('World', {delay: 100}); // Types slower, like a user
-    # ```
-    # 
-    # ```java
-    # elementHandle.type("Hello"); // Types instantly
-    # elementHandle.type("World", new ElementHandle.TypeOptions().setDelay(100)); // Types slower, like a user
-    # ```
-    # 
-    # ```python async
-    # await element_handle.type("hello") # types instantly
-    # await element_handle.type("world", delay=100) # types slower, like a user
-    # ```
-    # 
     # ```python sync
     # element_handle.type("hello") # types instantly
     # element_handle.type("world", delay=100) # types slower, like a user
     # ```
-    # 
-    # ```csharp
-    # await elementHandle.TypeAsync("Hello"); // Types instantly
-    # await elementHandle.TypeAsync("World", delay: 100); // Types slower, like a user
-    # ```
-    # 
+    #
     # An example of typing into a text field and then submitting the form:
-    # 
     #
-    # ```js
-    # const elementHandle = await page.$('input');
-    # await elementHandle.type('some text');
-    # await elementHandle.press('Enter');
-    # ```
-    # 
-    # ```java
-    # ElementHandle elementHandle = page.querySelector("input");
-    # elementHandle.type("some text");
-    # elementHandle.press("Enter");
-    # ```
-    # 
-    # ```python async
-    # element_handle = await page.query_selector("input")
-    # await element_handle.type("some text")
-    # await element_handle.press("Enter")
-    # ```
-    # 
     # ```python sync
     # element_handle = page.query_selector("input")
     # element_handle.type("some text")
     # element_handle.press("Enter")
     # ```
-    # 
-    # ```csharp
-    # var elementHandle = await page.QuerySelectorAsync("input");
-    # await elementHandle.TypeAsync("some text");
-    # await elementHandle.PressAsync("Enter");
-    # ```
     def type(text, delay: nil, noWaitAfter: nil, timeout: nil)
       wrap_impl(@impl.type(unwrap_impl(text), delay: unwrap_impl(delay), noWaitAfter: unwrap_impl(noWaitAfter), timeout: unwrap_impl(timeout)))
     end
@@ -729,9 +457,9 @@ module Playwright
     # 1. Use [`property: Page.mouse`] to click in the center of the element.
     # 1. Wait for initiated navigations to either succeed or fail, unless `noWaitAfter` option is set.
     # 1. Ensure that the element is now unchecked. If not, this method throws.
-    # 
+    #
     # If the element is detached from the DOM at any moment during the action, this method throws.
-    # 
+    #
     # When all steps combined have not finished during the specified `timeout`, this method throws a `TimeoutError`. Passing
     # zero timeout disables this.
     def uncheck(
@@ -744,7 +472,7 @@ module Playwright
     end
 
     # Returns when the element satisfies the `state`.
-    # 
+    #
     # Depending on the `state` parameter, this method waits for one of the [actionability](./actionability.md) checks to pass.
     # This method throws when the element is detached while waiting, unless waiting for the `"hidden"` state.
     # - `"visible"` Wait until the element is [visible](./actionability.md#visible).
@@ -755,7 +483,7 @@ module Playwright
     # - `"enabled"` Wait until the element is [enabled](./actionability.md#enabled).
     # - `"disabled"` Wait until the element is [not enabled](./actionability.md#enabled).
     # - `"editable"` Wait until the element is [editable](./actionability.md#editable).
-    # 
+    #
     # If the element does not satisfy the condition for the `timeout` milliseconds, this method will throw.
     def wait_for_element_state(state, timeout: nil)
       wrap_impl(@impl.wait_for_element_state(unwrap_impl(state), timeout: unwrap_impl(timeout)))
@@ -763,49 +491,19 @@ module Playwright
 
     # Returns element specified by selector when it satisfies `state` option. Returns `null` if waiting for `hidden` or
     # `detached`.
-    # 
+    #
     # Wait for the `selector` relative to the element handle to satisfy `state` option (either appear/disappear from dom, or
     # become visible/hidden). If at the moment of calling the method `selector` already satisfies the condition, the method
     # will return immediately. If the selector doesn't satisfy the condition for the `timeout` milliseconds, the function will
     # throw.
-    # 
     #
-    # ```js
-    # await page.setContent(`<div><span></span></div>`);
-    # const div = await page.$('div');
-    # // Waiting for the 'span' selector relative to the div.
-    # const span = await div.waitForSelector('span', { state: 'attached' });
-    # ```
-    # 
-    # ```java
-    # page.setContent("<div><span></span></div>");
-    # ElementHandle div = page.querySelector("div");
-    # // Waiting for the "span" selector relative to the div.
-    # ElementHandle span = div.waitForSelector("span", new ElementHandle.WaitForSelectorOptions()
-    #   .setState(WaitForSelectorState.ATTACHED));
-    # ```
-    # 
-    # ```python async
-    # await page.set_content("<div><span></span></div>")
-    # div = await page.query_selector("div")
-    # # waiting for the "span" selector relative to the div.
-    # span = await div.wait_for_selector("span", state="attached")
-    # ```
-    # 
     # ```python sync
     # page.set_content("<div><span></span></div>")
     # div = page.query_selector("div")
     # # waiting for the "span" selector relative to the div.
     # span = div.wait_for_selector("span", state="attached")
     # ```
-    # 
-    # ```csharp
-    # await page.SetContentAsync("<div><span></span></div>");
-    # var div = await page.QuerySelectorAsync("div");
-    # // Waiting for the "span" selector relative to the div.
-    # var span = await page.WaitForSelectorAsync("span", WaitForSelectorState.Attached);
-    # ```
-    # 
+    #
     # > NOTE: This method does not work across navigations, use [`method: Page.waitForSelector`] instead.
     def wait_for_selector(selector, state: nil, timeout: nil)
       wrap_impl(@impl.wait_for_selector(unwrap_impl(selector), state: unwrap_impl(state), timeout: unwrap_impl(timeout)))
@@ -813,20 +511,20 @@ module Playwright
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def off(event, callback)
-      event_emitter_proxy.off(event, callback)
+    def on(event, callback)
+      event_emitter_proxy.on(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def once(event, callback)
-      event_emitter_proxy.once(event, callback)
+    def off(event, callback)
+      event_emitter_proxy.off(event, callback)
     end
 
     # -- inherited from EventEmitter --
     # @nodoc
-    def on(event, callback)
-      event_emitter_proxy.on(event, callback)
+    def once(event, callback)
+      event_emitter_proxy.once(event, callback)
     end
 
     private def event_emitter_proxy