diff --git a/Browser/browser.py b/Browser/browser.py
old mode 100644
new mode 100755
index c89681cb8..1c13705d3
--- a/Browser/browser.py
+++ b/Browser/browser.py
@@ -38,50 +38,278 @@ class Browser(DynamicCore):
     [https://www.mozilla.org/en-US/firefox/new/|Firefox]
     and [https://webkit.org/|WebKit] with a single library.
 
+
     == Table of contents ==
 
     %TOC%
 
+    = Browser, Context and Page =
+
+    Browser library works with three different layers that build on each other:
+    *Browser*, *Context* and *Page*.
+
+
+    == Browsers ==
+
+    A *browser* can be started with one of the three
+    different engines Chromium, Firefox or Webkit.
+
+    === Supported Browsers ===
+    |   Browser     | Browser with this engine                          |
+    | ``chromium``  | Google Chrome, Microsoft Edge (since 2020), Opera |
+    | ``firefox``   | Mozilla Firefox                                   |
+    | ``webkit``    | Apple Safari, Mail, AppStore on MacOS and iOS     |
+
+    Since [https://github.com/microsoft/playwright|Playwright] comes with a pack of builtin
+    binaries for all browsers, no additional drivers e.g. geckodriver are needed.
+
+    All these browsers that cover more than 85% of the world wide used browsers,
+    can be tested on Windows, Linux and MacOS.
+    Theres is not need for dedicated machines anymore.
+
+    A browser process is started ``headless`` (without a GUI) by default.
+    Run `New Browser` with specified arguments if a browser with a GUI is requested
+    or if a proxy has to be configured.
+    A browser process can contain several contexts.
+
+
+    == Contexts ==
+
+    A *context* corresponds to several independent incognito browsers in Chrome
+    that do not share cookies, sessions or profile settings.
+    Compared to Selenium, these do *not* require their own browser process!
+    Therefore, to get a clean environment the tests shall just close the current
+    context and open a new context.
+    Due to this new independent browser sessions can be opened with
+    Robot Framework Browser about 10 times faster than with Selenium by
+    just opening a `New Context` within the opened browser.
+
+    The context layer is useful e.g. for testing different users sessions on the
+    same webpage without opening a whole new browser context.
+    Contexts can also have detailed configurations, such as geo-location, language settings,
+    the viewport size or color scheme.
+    Contexts do also support http credentials to be set, so that basic authentication
+    can also be tested. To be able to download files within the test,
+    the ``acceptDownloads`` argument must be set to ``True`` in `New Context` keyword.
+    A context can contain different pages.
+
+
+    == Pages ==
+
+    A *page* does contain the content of the loaded web site.
+    Pages and browser tabs are the same.
+
+    Typical usage could be:
+    | *** Test Cases ***
+    | Starting a browser with a page
+    |     New Browser    chromium    headless=false
+    |     New Context    viewport={'width': 1920, 'height': 1080}
+    |     New Page       https://marketsquare.github.io/robotframework-browser/Browser.html
+    |     Get Title      ==    Browser
+
+    There are shortcuts to open new pages together with new browsers but the offer less control.
+
+    The `Open Browser` keyword opens a new browser, a new context and a new page.
+    This keyword is usefull for quick experiments or debugging sessions.
+
+    When a `New Page` is called without an open browser, `New Browser`
+    and `New Context` are executed with default values first.
+
+    If there is no browser opened in Suite Setup and `New Page` is executed in
+    Test Setup, the corresponding pages and context is closed automatically at the end of
+    the test. The browser process remains open and will be closed at the end of
+    execution.
+
+    Each Browser, Context and Page has a unique ID with which they can be adressed.
+    A full catalog of what is open can be recieved by `Get Browser Catalog` as dictionary.
+
+
+
     = Finding elements =
 
     All keywords in the library that need to interact with an element
     on a web page take an argument typically named ``selector`` that specifies
     how to find the element.
 
-    == Selector syntax ==
+    Selector strategies that are supported by default are listed in the table
+    below.
 
-    Browser library supports the same selector strategies as the underlying
-    Playwright node module: xpath, css, id and text. The strategy can either
-    be explicitly specified with a prefix or the strategy can be implicit.
+    | = Strategy = |     = Match based on =     |         = Example =                |
+    | ``css``      | CSS selector.              | ``css=.class > #login_btn``        |
+    | ``xpath``    | XPath expression.          | ``xpath=//input[@id="login_btn"]`` |
+    | ``text``     | Browser text engine.       | ``text=Login``                     |
+    | ``id``       | Element ID Attribute.      | ``id=login_btn``                   |
 
-    === Implicit selector strategy ===
 
-    The default selector strategy is `css`. If selector does not contain
-    one of the know selector strategies, `css`, `xpath`, `id` or `text` it is
-    assumed to contain css selector. Also `selectors` starting with `//`
-    considered as xpath selectors.
+    == Explicit Selector Strategy ==
+
+    The explicit selector strategy is specified with a prefix using syntax
+    ``strategy=value``. Spaces around the separator are ignored, so
+    ``css=foo``, ``css= foo`` and ``css = foo`` are all equivalent.
+
+
+    == Implicit Selector Strategy ==
+
+    *The default selector strategy is `css`.*
+
+    If selector does not contain one of the know explicit selector strategies, it is
+    assumed to contain css selector.
+
+    Selectors that are starting with ``//`` or ``..`` are considered as xpath selectors.
+
+    Selectors that are in quotes are considered as text selectors.
 
     Examples:
 
-    | `Click` | span > button | # Use css selector strategy the element.   |
-    | `Click` | //span/button | # Use xpath selector strategy the element. |
+    | # CSS selectors are default.
+    | `Click`  span > button.some_class         # This is equivalent
+    | `Click`  css=span > button.some_class     # to this.
+    |
+    | # // or .. leads to xpath selector strategy
+    | `Click`  //span/button[@class="some_class"]
+    | `Click`  xpath=//span/button[@class="some_class"]
+    |
+    | # "text" in quotes leads to exact text selector strategy
+    | `Click`  "Login"
+    | `Click`  text="Login"
 
-    === Explicit selector strategy ===
 
-    The explicit selector strategy is specified with a prefix using syntax
-    ``strategy=value``. Spaces around the separator are ignored, so
-    ``css=foo``, ``css= foo`` and ``css = foo`` are all equivalent.
+    == CSS ==
 
+    As written before, the default selector strategy is `css`. See
+    [https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | css selector]
+    for more information.
 
-    Selector strategies that are supported by default are listed in the table
-    below.
+    Any malformed selector not starting with ``//`` or ``..`` nor starting and ending
+    with a quote is assumed to be a css selector.
+
+    Example:
+    | `Click`  span > button.some_class
+
+
+    == XPath ==
+
+    XPath engine is equivalent to [https://developer.mozilla.org/en/docs/Web/API/Document/evaluate|Document.evaluate].
+    Example: ``xpath=//html/body//span[text()="Hello World"]``.
+
+    Malformed selector starting with ``//`` or ``..`` is assumed to be an xpath selector.
+    For example, ``//html/body`` is converted to ``xpath=//html/body``. More
+    examples are displayed in `Examples`.
+
+    Note that xpath does not pierce [https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM|shadow_roots].
+
+
+    == Text ==
+
+    Text engine finds an element that contains a text node with the passed text.
+    For example, ``Click    text=Login`` clicks on a login button, and
+    ``Wait For Elements State   text="lazy loaded text"`` waits for the "lazy loaded text"
+    to appear in the page.
+
+    Malformed selector starting and ending with a quote (either ``"`` or ``'``) is assumed
+    to be a text selector. For example, ``Click    "Login"`` is converted to ``Click    text="Login"``.
+    Be aware that these leads to exact matches only!
+    More examples are displayed in `Examples`.
+
+
+    === insensitive match ===
+
+    By default, the match is case-insensitive, ignores leading/trailing whitespace and
+    searches for a substring. This means ``text= Login`` matches
+    ``<button>Button loGIN (click me)</button>``.
+
+    === exact match ===
+
+    Text body can be escaped with single or double quotes for precise matching,
+    insisting on exact match, including specified whitespace and case.
+    This means ``text="Login "`` will only match ``<button>Login </button>`` with exactly
+    one space after "Login". Quoted text follows the usual escaping rules, e.g.
+    use ``\\"`` to escape double quote in a double-quoted string: ``text="foo\\"bar"``.
+
+    === RegEx ===
+
+    Text body can also be a JavaScript-like regex wrapped in / symbols.
+    This means ``text=/^hello .*!$/i`` or ``text=/^Hello .*!$/`` will match ``<span>Hello Peter Parker!</span>``
+    with any name after ``Hello``, ending with ``!``.
+    The first one flagged with ``i`` for case-insensitive.
+    See [https://regex101.com/] for more information about RegEx.
+
+    === Button and Submit Values ===
 
-    | = Strategy = |     = Match based on =     |         = Example =            |
-    | css          | CSS selector.              | ``css=div#example``            |
-    | xpath        | XPath expression.          | ``xpath=//div[@id="example"]`` |
-    | text         | Browser text engine.       | ``text=Login``                 |
+    Input elements of the type button and submit are rendered with their value as text,
+    and text engine finds them. For example, ``text=Login`` matches
+    ``<input type=button value="Login">``.
 
-    == Finding elements inside frames ==
+
+
+    == Cascaded selector syntax ==
+
+    Browser library supports the same selector strategies as the underlying
+    Playwright node module: xpath, css, id and text. The strategy can either
+    be explicitly specified with a prefix or the strategy can be implicit.
+
+    A major advantage of Browser is, that multiple selector engines can be used
+    within one selector. It is possible to mix XPath, CSS and Text selectors while
+    selecting a single element.
+
+    Selectors are strings that consists of one or more clauses separated by
+    ``>>`` token, e.g. ``clause1 >> clause2 >> clause3``. When multiple clauses
+    are present, next one is queried relative to the previous one's result.
+    Browser library supports concatination of different selectors seperated by ``>>``.
+
+    For example:
+    | `Highlight Elements`    "Hello" >> ../.. >> .select_button
+    | `Highlight Elements`    text=Hello >> xpath=../.. >> css=.select_button
+
+    Each clause contains a selector engine name and selector body, e.g.
+    ``engine=body``. Here ``engine`` is one of the supported engines (e.g. css or
+    a custom one). Selector ``body`` follows the format of the particular engine,
+    e.g. for css engine it should be a [https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors | css selector].
+    Body format is assumed to ignore leading and trailing white spaces,
+    so that extra whitespace can be added for readability. If selector
+    engine needs to include ``>>`` in the body, it should be escaped
+    inside a string to not be confused with clause separator,
+    e.g. ``text="some >> text"``.
+
+    Selector engine name can be prefixed with ``*`` to capture element that
+    matches the particular clause instead of the last one. For example,
+    ``css=article >> text=Hello`` captures the element with the text ``Hello``,
+    and ``*css=article >> text=Hello`` (note the *) captures the article element
+    that contains some element with the text Hello.
+
+    For convenience, selectors in the wrong format are heuristically converted
+    to the right format. See `Implicit Selector Strategy`
+
+    == Examples ==
+    | # queries 'div' css selector
+    | Get Element    css=div
+    |
+    | # queries '//html/body/div' xpath selector
+    | Get Element    //html/body/div
+    |
+    | # queries '"foo"' text selector
+    | Get Element    text=foo
+    |
+    | # queries 'span' css selector inside the result of '//html/body/div' xpath selector
+    | Get Element    xpath=//html/body/div >> css=span
+    |
+    | # converted to 'css=div'
+    | Get Element    div
+    |
+    | # converted to 'xpath=//html/body/div'
+    | Get Element    //html/body/div
+    |
+    | # converted to 'text="foo"'
+    | Get Element    "foo"
+    |
+    | # queries the div element of every 2nd span element inside an element with the id foo
+    | Get Element    \\#foo >> css=span:nth-child(2n+1) >> div
+    | Get Element    id=foo >> css=span:nth-child(2n+1) >> div
+
+    Be aware that using ``#`` as a starting character in Robot Framework would be interpreted as comment.
+    Due to that fact a ``#id`` must be escaped as ``\\#id``.
+
+    == Frames ==
 
     By default, selector chains do not cross frame boundaries. It means that a
     simple CSS selector is not able to select and element located inside an iframe
@@ -90,12 +318,94 @@ class Browser(DynamicCore):
     inside a frame.
 
     Given this simple pseudo html snippet:
-    ``<iframe name="iframe" src="src.html"><button id="btn">Click Me</button></iframe>``,
-    here's a keyword call that clicks the button inside the frame.
+    | <iframe id="iframe" src="src.html">
+    |   #document
+    |     <!DOCTYPE html>
+    |     <html>
+    |       <head></head>
+    |       <body>
+    |         <button id="btn">Click Me</button>
+    |       </body>
+    |     </html>
+    | </iframe>
 
-    | Click  | iframe[name="iframe"] >>> #btn  |
+    Here's a keyword call that clicks the button inside the frame.
+
+    | Click   id=iframe >>> id=btn
 
     The selectors on the left and right side of ``>>>`` can be any valid selectors.
+    The selector clause directly before the frame opener ``>>>`` must select the frame element.
+
+    == WebComponents and Shadow DOM ==
+
+    Playwright and so also Browser are able to do automatic piercing of Shadow DOMs
+    and therefore are the best automation technology when working with WebComponents.
+
+    Also other technologies claim that they can handle
+    [https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM|Shadow DOM and Web Components].
+    However, non of them do pierce shadow roots automatically,
+    which may be inconvenient when working with Shadow DOM and Web Components.
+
+    For that reason, css engine pierces shadow roots. More specifically, every
+    [https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_combinator|Descendant combinator]
+    pierces an arbitrary number of open shadow roots, including the implicit descendant combinator
+    at the start of the selector.
+
+    That means, it is not nessesary to select each shadow host, open its shadow root and
+    select the next shadow host until you reach the element that should be controlled.
+
+    === CSS:light ===
+
+    ``css:light`` engine is equivalent to [https://developer.mozilla.org/en/docs/Web/API/Document/querySelector | Document.querySelector]
+    and behaves according to the CSS spec.
+    However, it does not pierce shadow roots.
+
+    ``css`` engine first searches for elements in the light dom in the iteration order,
+    and then recursively inside open shadow roots in the iteration order. It does not
+    search inside closed shadow roots or iframes.
+
+    Examples:
+
+    | <article>
+    |   <div>In the light dom</div>
+    |   <div slot='myslot'>In the light dom, but goes into the shadow slot</div>
+    |   <open mode shadow root>
+    |       <div class='in-the-shadow'>
+    |           <span class='content'>
+    |               In the shadow dom
+    |               <open mode shadow root>
+    |                   <li id='target'>Deep in the shadow</li>
+    |               </open mode shadow root>
+    |           </span>
+    |       </div>
+    |       <slot name='myslot'></slot>
+    |   </open mode shadow root>
+    | </article>
+
+    Note that ``<open mode shadow root>`` is not an html element, but rather a shadow root
+    created with ``element.attachShadow({mode: 'open'})``.
+
+    - Both ``"css=article div"`` and ``"css:light=article div"`` match the first ``<div>In the light dom</div>``.
+    - Both ``"css=article > div"`` and ``"css:light=article > div"`` match two ``div`` elements that are direct children of the ``article``.
+    - ``"css=article .in-the-shadow"`` matches the ``<div class='in-the-shadow'>``, piercing the shadow root, while ``"css:light=article .in-the-shadow"`` does not match anything.
+    - ``"css:light=article div > span"`` does not match anything, because both light-dom ``div`` elements do not contain a ``span``.
+    - ``"css=article div > span"`` matches the ``<span class='content'>``, piercing the shadow root.
+    - ``"css=article > .in-the-shadow"`` does not match anything, because ``<div class='in-the-shadow'>`` is not a direct child of ``article``
+    - ``"css:light=article > .in-the-shadow"`` does not match anything.
+    - ``"css=article li#target"`` matches the ``<li id='target'>Deep in the shadow</li>``, piercing two shadow roots.
+
+    === text:light ===
+
+    ``text`` engine open pierces shadow roots similarly to ``css``, while ``text:light`` does not.
+    Text engine first searches for elements in the light dom in the iteration order, and then
+    recursively inside open shadow roots in the iteration order. It does not search inside
+    closed shadow roots or iframes.
+
+    === id, data-testid, data-test-id, data-test and their :light counterparts ===
+
+    Attribute engines are selecting based on the corresponding attribute value.
+    For example: ``data-test-id=foo`` is equivalent to ``css=[data-test-id="foo"]``,
+    and ``id:light=foo`` is equivalent to ``css:light=[id="foo"]``.
 
     == Element reference syntax ==
 
@@ -103,8 +413,8 @@ class Browser(DynamicCore):
     reference can be used as a *first* part of a selector by using a special selector
     syntax `element=` like this:
 
-    | ${ref}=  |  Get Element  |  .some_class                    |
-    |          | Click         |  element=${ref} >>  .some_child |
+    | ${ref}=    Get Element    .some_class
+    |            Click          element=${ref} >> .some_child
 
     The `.some_child` selector in the example is relative to the element referenced by ${ref}.
 
@@ -145,12 +455,12 @@ class Browser(DynamicCore):
 
     == Examples ==
 
-    | Keyword   | Selector                 | Key      | Assertion Operator | Assertion Expected                                   |
-    | Get Title  |                         |          | equal              | Page Title                                           |
-    | Get Style  |  //*[@id="div-element"] |   width  |  >                 |  100                                                 |
-    | Get Title  |                         |          |  matches           |  \\\\w+\\\\s\\\\w+                                   |
-    | Get Title  |                         |          |  validate          |  value == "Login Page"                               |
-    | Get Title  |                         |          |  evaluate          | value if value == "some value" else "something else" |
+    | *Keyword*    |  *Selector*             | *Key*    | *Assertion Operator* | *Assertion Expected*                                 |
+    | `Get Title`  |                         |          | equal                | Page Title                                           |
+    | `Get Style`  |  //*[@id="div-element"] |   width  |  >                   |  100                                                 |
+    | `Get Title`  |                         |          |  matches             |  \\\\w+\\\\s\\\\w+                                   |
+    | `Get Title`  |                         |          |  validate            |  value == "Login Page"                               |
+    | `Get Title`  |                         |          |  evaluate            | value if value == "some value" else "something else" |
 
     = Automatic page and context closing =
 
diff --git a/Browser/keywords/browser_control.py b/Browser/keywords/browser_control.py
index dc8d1974c..f6120b68f 100644
--- a/Browser/keywords/browser_control.py
+++ b/Browser/keywords/browser_control.py
@@ -56,7 +56,7 @@ def _get_screenshot_path(self, filename: str) -> Path:
     def take_screenshot(self, filename: str = "", selector: str = ""):
         """Takes a screenshot of the current window and saves it to ``path``. Saves it as a png.
 
-        ``filename`` <str> Filename into which to save. The file will be saved into the robot framework output directory.
+        ``filename`` <str> Filename into which to save. The file will be saved into the robot framework output directory by default.
         String ``{index}`` in path will be replaced with a rolling number. Use this to not override filenames.
 
         ``selector`` <str> Take a screenshot of the element matched by selector.
diff --git a/Browser/keywords/cookie.py b/Browser/keywords/cookie.py
index 4b7b7fe5f..2c173950d 100644
--- a/Browser/keywords/cookie.py
+++ b/Browser/keywords/cookie.py
@@ -100,13 +100,13 @@ def add_cookie(
 
         ``secure`` <bool> Sets the secure token.
 
-        ``samesite`` <Strict|Lax|None> Sets the samesite mode.
+        ``samesite`` < ``Strict`` | ``Lax`` | ``None`` > Sets the samesite mode.
 
         Example:
-        | `Add Cookie` | foo | bar | http://address.com/path/to/site |                                 | # Using url argument.             |
-        | `Add Cookie` | foo | bar | domain=example.com              | path=/foo/bar                   | # Using domain and url arguments. |
-        | `Add Cookie` | foo | bar | http://address.com/path/to/site | expiry=2027-09-28 16:21:35      | # Expiry as timestamp.            |
-        | `Add Cookie` | foo | bar | http://address.com/path/to/site | expiry=1822137695               | # Expiry as epoch seconds.        |
+        | `Add Cookie`   foo   bar   http://address.com/path/to/site                                     # Using url argument.
+        | `Add Cookie`   foo   bar   domain=example.com                path=/foo/bar                     # Using domain and url arguments.
+        | `Add Cookie`   foo   bar   http://address.com/path/to/site   expiry=2027-09-28 16:21:35        # Expiry as timestamp.
+        | `Add Cookie`   foo   bar   http://address.com/path/to/site   expiry=1822137695                 # Expiry as epoch seconds.
         """
         params = locals_to_params(locals())
         if expires:
@@ -152,6 +152,8 @@ def get_cookie(
     ) -> Union[DotDict, str]:
         """Returns information of cookie with ``name`` as a Robot Framework dot dictionary or a string.
 
+        ``cookie`` <str> Name of the cookie to be retrieved.
+
         If ``return_type`` is ``dictionary`` or ``dict`` then keyword returns a of Robot Framework
         [https://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#accessing-list-and-dictionary-items|dot dictionary]
         The dictionary contains all possible key value pairs of the cookie. If ``return_type`` is ``string`` or ``str``,
@@ -161,7 +163,7 @@ def get_cookie(
         If no cookie is found with ``name`` keyword fails. The cookie dictionary contains
         details about the cookie. Keys available in the dictionary are documented in the table below.
 
-        | Value    | Explanation                                                                                |
+        | *Value*  | *Explanation*                                                                              |
         | name     | The name of a cookie, mandatory.                                                           |
         | value    | Value of the cookie, mandatory.                                                            |
         | url      | Define the scope of the cookie, what URLs the cookies should be sent to.                   |
@@ -177,9 +179,9 @@ def get_cookie(
         for details about each attribute.
 
         Example:
-        | ${cookie} =     | Get Cookie            | Foobar  |
-        | Should Be Equal | ${cookie.value}       | Tidii   |
-        | Should Be Equal | ${cookie.expiry.year} | ${2020} |
+        | ${cookie}=        Get Cookie              Foobar
+        | Should Be Equal   ${cookie.value}         Tidii
+        | Should Be Equal   ${cookie.expiry.year}   ${2020}
         """
         _, cookies = self._get_cookies()
         for cookie_dict in cookies:
diff --git a/Browser/keywords/device_descriptors.py b/Browser/keywords/device_descriptors.py
index 709996279..19096c0f2 100644
--- a/Browser/keywords/device_descriptors.py
+++ b/Browser/keywords/device_descriptors.py
@@ -35,10 +35,10 @@ def get_device(self, name: str):
             before using ensure your active page is on that context.
             Usage:
 
-            | ${device}=   | Get Device        | iPhone X
-            |              | New Context       | &{device}
-            |              | New Page          |
-            |              | Get Viewport Size | returns { "width": 375, "height": 812 }
+            | ${device}=          Get Device       iPhone X
+            | New Context         &{device}
+            | New Page
+            | Get Viewport Size   returns { "width": 375, "height": 812 }
         """
         with self.playwright.grpc_channel() as stub:
             response = stub.GetDevice(Request().Device(name=name))
diff --git a/Browser/keywords/evaluation.py b/Browser/keywords/evaluation.py
index efe75957c..77887a07f 100644
--- a/Browser/keywords/evaluation.py
+++ b/Browser/keywords/evaluation.py
@@ -47,7 +47,7 @@ def highlight_elements(
 
         ``width`` <str> Sets the width of the higlight border. Defaults to 2px.
 
-        ``style`` <solid|dotted|double|dashed> Sets the style of the border. Defaults to dotted.
+        ``style`` < ``solid`` | ``dotted`` | ``double`` | ``dashed`` > Sets the style of the border. Defaults to dotted.
 
         ``color`` <str> Sets the color of the border. Valid colors i.e. are:
         ``red``, ``blue``, ``yellow``, ``pink``, ``black``
diff --git a/Browser/keywords/getters.py b/Browser/keywords/getters.py
index 3a374435a..5ff0f2eee 100644
--- a/Browser/keywords/getters.py
+++ b/Browser/keywords/getters.py
@@ -198,7 +198,7 @@ def get_selected_options(
         ``selector`` <str> Selector from which the info is to be retrieved. **Required**
 
         ``option_attribute`` <SelectAttribute.label> Which attribute shall be returned/verified.
-        Allowed values are ``<"value"|"label"|"text"|"index">``. Defaults to label.
+        Allowed values are ``< ``value`` | ``label`` | ``text`` | ``index`` >``. Defaults to label.
 
         ``assertion_operator`` <AssertionOperator> See `Assertions` for further details. Defaults to None.
 
@@ -209,13 +209,13 @@ def get_selected_options(
 
         Example:
 
-        | `Select Options By`    | label                  | //select[2]  | Email    | Mobile           |      |                     |
-        | ${selected_list}       | `Get Selected Options` | //select[2]  |          |                  |      | # getter            |
-        | `Get Selected Options` | //select[2]            | label        | `==`     | Mobile           | Mail | #assertion content  |
-        | `Select Options By`    | label                  | select#names | 2        | 4                |      |                     |
-        | `Get Selected Options` | select#names           | index        | `==`     | 2                | 4    | #assertion index    |
-        | `Get Selected Options` | select#names           | label        | *=       | Mikko            |      | #assertion contains |
-        | `Get Selected Options` | select#names           | label        | validate | len(value) == 3  |      | #assertion length   |
+        | `Select Options By`      label                    //select[2]    Email      Mobile
+        | ${selected_list}         `Get Selected Options`   //select[2]                                         # getter
+        | `Get Selected Options`   //select[2]              label          `==`       Mobile             Mail   #assertion content
+        | `Select Options By`      label                    select#names   2          4
+        | `Get Selected Options`   select#names             index          `==`       2                  4      #assertion index
+        | `Get Selected Options`   select#names             label          *=         Mikko                     #assertion contain
+        | `Get Selected Options`   select#names             label          validate   len(value) == 3           #assertion length
 
         """
         with self.playwright.grpc_channel() as stub:
@@ -296,8 +296,6 @@ def get_element_count(
         ``assertion_operator`` <AssertionOperator> See `Assertions` for further details. Defaults to None.
 
         ``expected_value`` <str|int> Expected value for the counting
-
-
         """
         with self.playwright.grpc_channel() as stub:
             response = stub.GetElementCount(
@@ -460,15 +458,13 @@ def get_boundingbox(
             See `Assertions` for further details for the assertion arguments. Defaults to None.
 
             Example use:
-            | ${bounding_box}=    Get BoundingBox    id=element    # unfiltered
-            | Log    ${bounding_box}    # {'x': 559.09375, 'y': 75.5, 'width': 188.796875, 'height': 18}
-            | ${x}=    Get BoundingBox    id=element    x    # filtered
-            | Log    X: ${x}    # X: 559.09375
+            | ${bounding_box}=    Get BoundingBox    id=element                 # unfiltered
+            | Log                 ${bounding_box}                               # {'x': 559.09375, 'y': 75.5, 'width': 188.796875, 'height': 18}
+            | ${x}=               Get BoundingBox    id=element    x            # filtered
+            | Log                 X: ${x}                                       # X: 559.09375
             | # Assertions:
-            | Get BoundingBox    id=element    width    >    180
-            | Get BoundingBox    id=element    ALL    validate    value['x'] > value['y']*2
-
-
+            | Get BoundingBox     id=element         width         >    180
+            | Get BoundingBox     id=element         ALL           validate    value['x'] > value['y']*2
         """
         with self.playwright.grpc_channel() as stub:
             response = stub.GetBoundingBox(Request.ElementSelector(selector=selector))
diff --git a/Browser/keywords/interaction.py b/Browser/keywords/interaction.py
index 4c99822c7..a036366f9 100644
--- a/Browser/keywords/interaction.py
+++ b/Browser/keywords/interaction.py
@@ -1,478 +1,478 @@
-import json
-from pathlib import Path
-from typing import Dict, Optional
-
-from robotlibcore import keyword  # type: ignore
-
-from ..base import LibraryComponent
-from ..generated.playwright_pb2 import Request
-from ..utils import logger
-from ..utils.data_types import (
-    AlertAction,
-    KeyAction,
-    KeyboardInputAction,
-    KeyboardModifier,
-    MouseButton,
-    MouseButtonAction,
-    MouseOptionsDict,
-    SelectAttribute,
-)
-from ..utils.time_conversion import timestr_to_millisecs
-
-
-class Interaction(LibraryComponent):
-    @keyword(tags=["Setter", "PageContent"])
-    def type_text(
-        self, selector: str, text: str, delay: str = "0 ms", clear: bool = True
-    ):
-        """Types the given ``text`` into the text field found by ``selector``.
-
-        Sends a ``keydown``, ``keypress/input``, and ``keyup`` event for each
-        character in the text.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        ``text`` <str> Text for the text field. **Required**
-
-        ``delay`` <str> Delay between the single key strokes. It may be either a
-        number or a Robot Framework time string. Time strings are fully
-        explained in an appendix of Robot Framework User Guide. Defaults to ``0 ms``.
-        Example: ``50 ms``
-
-        ``clear`` <bool> Set to false, if the field shall not be cleared before typing.
-        Defaults to true.
-
-        See `Fill Text` for direct filling of the full text at once.
-        """
-        self._type_text(selector, text, delay, clear)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def fill_text(self, selector: str, text: str):
-        """Clears and fills the given ``text`` into the text field found by ``selector``.
-
-        This method waits for an element matching the ``selector`` to appear,
-        waits for actionability checks, focuses the element, fills it and
-        triggers an input event after filling.
-
-        If the element matching selector is not an <input>, <textarea> or
-        [contenteditable] element, this method throws an error. Note that
-        you can pass an empty string as ``text`` to clear the input field.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        ``text`` <str> Text for the text field. **Required**
-
-        See `Type Text` for emulating typing text character by character.
-        """
-        self._fill_text(selector, text)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def clear_text(self, selector: str):
-        """Clears the text field found by ``selector``.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        See `Type Text` for emulating typing text character by character.
-        See `Fill Text` for direct filling of the full text at once.
-
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.ClearText(Request().ClearText(selector=selector))
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def type_secret(
-        self, selector: str, secret: str, delay: str = "0 ms", clear: bool = True
-    ):
-        """Types the given ``secret`` into the text field found by ``selector``.
-
-        The difference to `Type Text` is that this keyword does not log the
-        text to be written into the text field.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        ``secret`` <str> Secret text for the text field. **Required**
-
-        ``delay`` <str> Delay between the single key strokes. It may be either a
-        number or a Robot Framework time string. Time strings are fully
-        explained in an appendix of Robot Framework User Guide. Defaults to ``0 ms``.
-        Example: ``50 ms``
-
-        ``clear`` <bool> Set to false, if the field shall not be cleared before typing.
-        Defaults to true.
-
-        See `Type Text` for details.
-        """
-        self._type_text(selector, secret, delay, clear, log_response=False)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def fill_secret(self, selector: str, secret: str):
-        """Fills the given ``secret`` into the text field found by ``selector``.
-
-        The difference to `Fill Text` is that this keyword does not log the
-        text to be written into the text field.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        ``secret`` <str> Secret text for the text field. **Required**
-
-        See `Fill Text` for details.
-        """
-        self._fill_text(selector, secret, log_response=False)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def press_keys(self, selector: str, *keys: str):
-        """Types the given key combination into element found by ``selector``.
-
-        ``selector`` <str> Selector of the text field. **Required**
-
-        Supports values like "a, b" which will be automatically typed.
-        .
-        Also supports identifiers for keys like ``ArrowLeft`` or ``Backspace``.
-        Using + to chain combine modifiers with a single keypress
-        ``Control+Shift+T`` is supported.
-
-        See playwright's documentation for a more comprehensive list of
-        supported input keys.
-        [https://github.com/microsoft/playwright/blob/master/docs/api.md#pagepressselector-key-options | Playwright docs for press.]
-
-        Example: 
-
-        | Keyword      | Selector                   | Keys | Keys | Keys | Keys | Keys        | Keys |
-        | Press Keys   | //*[@id="username_field"]  |  h   |   e  |  l   |  o   |  ArrowLeft  |  l   |
-        """  # noqa
-        with self.playwright.grpc_channel() as stub:
-            response = stub.Press(Request().PressKeys(selector=selector, key=keys))
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def click(self, selector: str):
-        """Clicks the element found by ``selector``.
-
-        ``selector`` <str> Selector of the element to click. **Required**
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.Click(Request().ElementSelector(selector=selector))
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def click_with_options(
-        self,
-        selector: str,
-        button: MouseButton = MouseButton.left,
-        click_count: int = 1,
-        delay: Optional[str] = None,
-        position_x: Optional[int] = None,
-        position_y: Optional[int] = None,
-        force: bool = False,
-        *modifiers: KeyboardModifier,
-    ):
-        """Simulates mouse click with multiple options on the element found by ``selector``.
-
-        ``selector`` <str> Selector element to click. **Required**
-
-        ``button`` <left|right|middle> Defaults to ``left`` if invalid.
-
-        ``click_count`` <int> Defaults to 1.
-
-        ``delay`` <robot time> Time to wait between mousedown and mouseup in milliseconds.
-        Defaults to 0.
-
-        ``position_x`` & ``position_y`` <int> A point to click relative to the
-        top-left corner of element padding box.
-        If not specified, clicks to some visible point of the element.
-
-        ``force`` <bool> Set to True to skip Playwright's [https://github.com/microsoft/playwright/blob/master/docs/actionability.md | Actionability checks].
-
-        ``*modifiers`` ``<Alt|Control|Meta|Shift>``
-        Modifier keys to press. Ensures that only these modifiers are pressed
-        during the click, and then restores current modifiers back.
-        If not specified, currently pressed modifiers are used.
-        """
-        with self.playwright.grpc_channel() as stub:
-            options = {"button": button.name, "clickCount": click_count, "force": force}
-            if delay:
-                options["delay"] = timestr_to_millisecs(delay)
-            if position_x and position_y:
-                positions: Dict[str, object] = {"x": position_x, "y": position_y}
-                options["position"] = positions
-            if modifiers:
-                options["modifiers"] = [m.name for m in modifiers]
-            options_json = json.dumps(options)
-            logger.debug(f"Click Options are: {options_json}")
-            response = stub.ClickWithOptions(
-                Request().ElementSelectorWithOptions(
-                    selector=selector, options=options_json
-                )
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def focus(self, selector: str):
-        """Moves focus on to the element found by ``selector``.
-
-        ``selector`` <str> Selector of the element. **Required**
-
-        If there's no element matching selector, the method waits until a
-        matching element appears in the DOM. Timeouts after 10 seconds.
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.Focus(Request().ElementSelector(selector=selector))
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def check_checkbox(self, selector: str):
-        """Checks the checkbox or selects radio button found by ``selector``.
-
-        ``selector`` <str> Selector of the checkbox. **Required**
-
-        Does nothing if the element is already checked/selected.
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.CheckCheckbox(Request().ElementSelector(selector=selector))
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def uncheck_checkbox(self, selector: str):
-        """Unchecks the checkbox found by ``selector``.
-
-        ``selector`` <str> Selector of the checkbox. **Required**
-
-        Does nothing if the element is not checked/selected.
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.UncheckCheckbox(
-                Request().ElementSelector(selector=selector)
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def select_options_by(self, selector: str, attribute: SelectAttribute, *values):
-        """Selects options from select element found by ``selector``.
-
-        ``selector`` <str> Selector of the select tag. **Required**
-
-        Matches based on the chosen attribute with list of ``values``.
-        Possible attributes to match options by:
-        ``attribute`` ``<"value"|"label"|"text"|"index">``
-
-        If no values to select are passed will deselect options in element.
-        """
-        matchers = ""
-        if not values or len(values) == 1 and not values[0]:
-            self.deselect_options(selector)
-            return
-
-        if attribute is SelectAttribute.value:
-            matchers = json.dumps([{"value": s} for s in values])
-        elif attribute is SelectAttribute.label:
-            matchers = json.dumps([{"label": s} for s in values])
-        elif attribute is SelectAttribute.index:
-            matchers = json.dumps([{"index": int(s)} for s in values])
-        with self.playwright.grpc_channel() as stub:
-            response = stub.SelectOption(
-                Request().SelectElementSelector(selector=selector, matcherJson=matchers)
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent"])
-    def deselect_options(self, selector: str):
-        """Deselects all options from select element found by ``selector``.
-
-        ``selector`` <str> Selector of the select tag. **Required**
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.DeselectOption(Request().ElementSelector(selector=selector))
-            logger.debug(response.log)
-
-    def _fill_text(self, selector: str, text: str, log_response: bool = True):
-        with self.playwright.grpc_channel() as stub:
-            response = stub.FillText(Request().FillText(selector=selector, text=text))
-            if log_response:
-                logger.debug(response.log)
-
-    def _type_text(
-        self,
-        selector: str,
-        text: str,
-        delay: str = "0 ms",
-        clear: bool = True,
-        log_response: bool = True,
-    ):
-        with self.playwright.grpc_channel() as stub:
-            delay_ms = timestr_to_millisecs(delay)
-            response = stub.TypeText(
-                Request().TypeText(
-                    selector=selector, text=text, delay=int(delay_ms), clear=clear
-                )
-            )
-            if log_response:
-                logger.debug(response.log)
-
-    @keyword(tags=["Setter", "PageContent", "EventHandler"])
-    def upload_file(self, path: str):
-        """ Upload file from ``path`` into next file chooser dialog on page.
-
-        ``path`` <str> Path to file to be uploaded.
-
-        Example use:
-
-            | Upload File |  ${CURDIR}/test_upload_file |
-            | Click       |  \\#file_chooser            |
-
-        """
-        p = Path(path)
-        p.resolve(strict=True)
-        with self.playwright.grpc_channel() as stub:
-            response = stub.UploadFile(Request().FilePath(path=str(p)))
-            logger.debug(response.log)
-
-    @keyword(tags=["PageContent", "EventHandler"])
-    def handle_alert(self, action: AlertAction, prompt_input: str = ""):
-        """ Handle next dialog on page with ``action``. Dialog can be any of alert,
-        beforeunload, confirm or prompt.
-
-            ``action`` <accept|dismiss> How to handle the alert. **Required**
-
-            ``prompt_input`` <str> The value to enter into prompt. Only valid if
-            ``action`` equals accept. Defaults to empty string.
-        """
-
-        with self.playwright.grpc_channel() as stub:
-            if prompt_input and action is not AlertAction.accept:
-                raise ValueError("prompt_input is only valid if action is 'accept'")
-            response = stub.HandleAlert(
-                Request().AlertAction(alertAction=action.name, promptInput=prompt_input)
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["VirtualMouse", "PageContent"])
-    def mouse_button(
-        self,
-        action: MouseButtonAction,
-        x: Optional[float] = None,
-        y: Optional[float] = None,
-        button: MouseButton = MouseButton.left,
-        clickCount: int = 1,
-        delay: int = 0,
-    ):
-        """ Click, hold a mouse button down or release it. Moving the mouse between holding down
-        and releasing it for example is possible.
-
-            ``action`` <click|up|down> Determines if it is a mouseclick, holding down a key or releasing it.
-
-            ``x`` <int> and ``y`` <int> Coordinates for a click only. Defaults to None.
-            **Required** if action is a click.
-
-            ``button`` <left|right|middle> Defaults to ``left`` if invalid.
-
-            ``clickCount`` <int> Deterine how often shall be clicked. Defaults to 1.
-
-            ``delay`` <int> Delay in ms between the mousedown and mouseup event. Can only be set if the action is click.
-        """
-        with self.playwright.grpc_channel() as stub:
-            body: MouseOptionsDict = {}
-            if delay and action is not MouseButtonAction.click:
-                raise ValueError("Delay is only valid on a mouse click")
-            if action is MouseButtonAction.down or action is MouseButtonAction.up:
-                if x or y:
-                    raise ValueError(
-                        "Coordinates are not valid on MouseAction.up or MouseAction.down"
-                    )
-                body = {
-                    "options": {
-                        "button": button.name,
-                        "clickCount": clickCount,
-                        "delay": delay,
-                    }
-                }
-            else:
-                body = {}
-                if x:
-                    body["x"] = float(x)
-                if y:
-                    body["y"] = float(y)
-                body["options"] = {
-                    "button": button.name,
-                    "clickCount": clickCount,
-                    "delay": delay,
-                }
-
-            response = stub.MouseButton(
-                Request().MouseButtonOptions(action=action.name, json=json.dumps(body))
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["VirtualMouse", "PageContent"])
-    def mouse_move(self, x: float, y: float, steps: int = 1):
-        """ Instead of selectors command mouse with coordinates.
-            The Click commands will leave the virtual mouse on the specified coordinates.
-
-            ``x`` <float> ``y`` <float> are absolute coordinates starting at the top left
-            of the page.
-
-            ``steps`` <int> Number of intermediate steps for the mouse event.
-        """
-        with self.playwright.grpc_channel() as stub:
-            body: MouseOptionsDict = {"x": x, "y": y, "options": {"steps": steps}}
-            response = stub.MouseMove(Request().Json(body=json.dumps(body)))
-            logger.debug(response.log)
-
-    @keyword(tags=["VirtualKeyboard", "PageContent"])
-    def keyboard_key(self, action: KeyAction, key: str):
-        """ Press a keyboard key on the virtual keyboard or set a key up or down.
-
-        ``action`` <up|down|press> Determine whether the key should be released,
-        hold or pressed. ``down`` or ``up`` are useful for combinations i.e. with Shift.
-        **Required**
-
-        ``key`` <str> The key to be pressed. An example of valid 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.
-
-        Useful keys for ``down`` and ``up`` for example are:
-
-        ``Shift``, ``Control``, ``Alt``, ``Meta``, ``ShiftLeft``
-
-        Example excecution:
-        | Keyboard Key | press | S         |
-        | Keyboard Key | down  | Shift     |
-        | Keyboard Key | press | ArrowLeft |
-        | Keyboard Key | press | Delete    |
-        | Keyboard Key | up    | Shift     |
-
-        Note: Capital letters don't need to be written by the help of Shift. You can type them in directly.
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.KeyboardKey(
-                Request().KeyboardKeypress(action=action.name, key=key)
-            )
-            logger.debug(response.log)
-
-    @keyword(tags=["VirtualKeyboard", "PageContent"])
-    def keyboard_input(self, action: KeyboardInputAction, input: str, delay=0):
-        """ Input text into page with virtual keyboard.
-
-            ``action`` <insertText|type> **Required**
-
-                - ``insertText`` Dispatches only input event, does not emit the keydown, keyup or keypress events.
-
-                - ``type`` Sends a keydown, keypress/input, and keyup event for each character in the text.
-
-            ``input`` <str> The inputstring to be typed. No special keys possible. **Required**
-
-            Note: To press a special key, like Control or ArrowDown, use keyboard.press.
-            Modifier keys DO NOT effect these methods. For testing modifier effects use single key
-            presses with ``Keyboard Key  press``
-
-        """
-        with self.playwright.grpc_channel() as stub:
-            response = stub.KeyboardInput(
-                Request().KeyboardInputOptions(
-                    action=action.name, input=input, delay=delay
-                )
-            )
-            logger.debug(response.log)
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+from robotlibcore import keyword  # type: ignore
+
+from ..base import LibraryComponent
+from ..generated.playwright_pb2 import Request
+from ..utils import logger
+from ..utils.data_types import (
+    AlertAction,
+    KeyAction,
+    KeyboardInputAction,
+    KeyboardModifier,
+    MouseButton,
+    MouseButtonAction,
+    MouseOptionsDict,
+    SelectAttribute,
+)
+from ..utils.time_conversion import timestr_to_millisecs
+
+
+class Interaction(LibraryComponent):
+    @keyword(tags=["Setter", "PageContent"])
+    def type_text(
+        self, selector: str, text: str, delay: str = "0 ms", clear: bool = True
+    ):
+        """Types the given ``text`` into the text field found by ``selector``.
+
+        Sends a ``keydown``, ``keypress/input``, and ``keyup`` event for each
+        character in the text.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        ``text`` <str> Text for the text field. **Required**
+
+        ``delay`` <str> Delay between the single key strokes. It may be either a
+        number or a Robot Framework time string. Time strings are fully
+        explained in an appendix of Robot Framework User Guide. Defaults to ``0 ms``.
+        Example: ``50 ms``
+
+        ``clear`` <bool> Set to false, if the field shall not be cleared before typing.
+        Defaults to true.
+
+        See `Fill Text` for direct filling of the full text at once.
+        """
+        self._type_text(selector, text, delay, clear)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def fill_text(self, selector: str, text: str):
+        """Clears and fills the given ``text`` into the text field found by ``selector``.
+
+        This method waits for an element matching the ``selector`` to appear,
+        waits for actionability checks, focuses the element, fills it and
+        triggers an input event after filling.
+
+        If the element matching selector is not an <input>, <textarea> or
+        [contenteditable] element, this method throws an error. Note that
+        you can pass an empty string as ``text`` to clear the input field.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        ``text`` <str> Text for the text field. **Required**
+
+        See `Type Text` for emulating typing text character by character.
+        """
+        self._fill_text(selector, text)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def clear_text(self, selector: str):
+        """Clears the text field found by ``selector``.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        See `Type Text` for emulating typing text character by character.
+        See `Fill Text` for direct filling of the full text at once.
+
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.ClearText(Request().ClearText(selector=selector))
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def type_secret(
+        self, selector: str, secret: str, delay: str = "0 ms", clear: bool = True
+    ):
+        """Types the given ``secret`` into the text field found by ``selector``.
+
+        The difference to `Type Text` is that this keyword does not log the
+        text to be written into the text field.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        ``secret`` <str> Secret text for the text field. **Required**
+
+        ``delay`` <str> Delay between the single key strokes. It may be either a
+        number or a Robot Framework time string. Time strings are fully
+        explained in an appendix of Robot Framework User Guide. Defaults to ``0 ms``.
+        Example: ``50 ms``
+
+        ``clear`` <bool> Set to false, if the field shall not be cleared before typing.
+        Defaults to true.
+
+        See `Type Text` for details.
+        """
+        self._type_text(selector, secret, delay, clear, log_response=False)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def fill_secret(self, selector: str, secret: str):
+        """Fills the given ``secret`` into the text field found by ``selector``.
+
+        The difference to `Fill Text` is that this keyword does not log the
+        text to be written into the text field.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        ``secret`` <str> Secret text for the text field. **Required**
+
+        See `Fill Text` for details.
+        """
+        self._fill_text(selector, secret, log_response=False)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def press_keys(self, selector: str, *keys: str):
+        """Types the given key combination into element found by ``selector``.
+
+        ``selector`` <str> Selector of the text field. **Required**
+
+        Supports values like "a, b" which will be automatically typed.
+        .
+        Also supports identifiers for keys like ``ArrowLeft`` or ``Backspace``.
+        Using + to chain combine modifiers with a single keypress
+        ``Control+Shift+T`` is supported.
+
+        See playwright's documentation for a more comprehensive list of
+        supported input keys.
+        [https://github.com/microsoft/playwright/blob/master/docs/api.md#pagepressselector-key-options | Playwright docs for press.]
+
+        Example: 
+
+        | # Keyword       Selector                    *Keys
+        | Press Keys      //*[@id="username_field"]    h    e   l   o   ArrowLeft   l
+        """  # noqa
+        with self.playwright.grpc_channel() as stub:
+            response = stub.Press(Request().PressKeys(selector=selector, key=keys))
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def click(self, selector: str):
+        """Clicks the element found by ``selector``.
+
+        ``selector`` <str> Selector of the element to click. **Required**
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.Click(Request().ElementSelector(selector=selector))
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def click_with_options(
+        self,
+        selector: str,
+        button: MouseButton = MouseButton.left,
+        click_count: int = 1,
+        delay: Optional[str] = None,
+        position_x: Optional[int] = None,
+        position_y: Optional[int] = None,
+        force: bool = False,
+        *modifiers: KeyboardModifier,
+    ):
+        """Simulates mouse click with multiple options on the element found by ``selector``.
+
+        ``selector`` <str> Selector element to click. **Required**
+
+        ``button`` < ``left`` | ``right`` | ``middle`` > Defaults to ``left`` if invalid.
+
+        ``click_count`` <int> Defaults to 1.
+
+        ``delay`` <robot time> Time to wait between mousedown and mouseup in milliseconds.
+        Defaults to 0.
+
+        ``position_x`` & ``position_y`` <int> A point to click relative to the
+        top-left corner of element padding box.
+        If not specified, clicks to some visible point of the element.
+
+        ``force`` <bool> Set to True to skip Playwright's [https://github.com/microsoft/playwright/blob/master/docs/actionability.md | Actionability checks].
+
+        ``*modifiers`` < ``Alt`` | ``Control`` | ``Meta`` | ``Shift`` >
+        Modifier keys to press. Ensures that only these modifiers are pressed
+        during the click, and then restores current modifiers back.
+        If not specified, currently pressed modifiers are used.
+        """
+        with self.playwright.grpc_channel() as stub:
+            options = {"button": button.name, "clickCount": click_count, "force": force}
+            if delay:
+                options["delay"] = timestr_to_millisecs(delay)
+            if position_x and position_y:
+                positions: Dict[str, object] = {"x": position_x, "y": position_y}
+                options["position"] = positions
+            if modifiers:
+                options["modifiers"] = [m.name for m in modifiers]
+            options_json = json.dumps(options)
+            logger.debug(f"Click Options are: {options_json}")
+            response = stub.ClickWithOptions(
+                Request().ElementSelectorWithOptions(
+                    selector=selector, options=options_json
+                )
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def focus(self, selector: str):
+        """Moves focus on to the element found by ``selector``.
+
+        ``selector`` <str> Selector of the element. **Required**
+
+        If there's no element matching selector, the method waits until a
+        matching element appears in the DOM. Timeouts after 10 seconds.
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.Focus(Request().ElementSelector(selector=selector))
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def check_checkbox(self, selector: str):
+        """Checks the checkbox or selects radio button found by ``selector``.
+
+        ``selector`` <str> Selector of the checkbox. **Required**
+
+        Does nothing if the element is already checked/selected.
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.CheckCheckbox(Request().ElementSelector(selector=selector))
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def uncheck_checkbox(self, selector: str):
+        """Unchecks the checkbox found by ``selector``.
+
+        ``selector`` <str> Selector of the checkbox. **Required**
+
+        Does nothing if the element is not checked/selected.
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.UncheckCheckbox(
+                Request().ElementSelector(selector=selector)
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def select_options_by(self, selector: str, attribute: SelectAttribute, *values):
+        """Selects options from select element found by ``selector``.
+
+        ``selector`` <str> Selector of the select tag. **Required**
+
+        Matches based on the chosen attribute with list of ``values``.
+        Possible attributes to match options by:
+        ``attribute`` < ``value`` | ``label `` | ``text`` | ``index`` >
+
+        If no values to select are passed will deselect options in element.
+        """
+        matchers = ""
+        if not values or len(values) == 1 and not values[0]:
+            self.deselect_options(selector)
+            return
+
+        if attribute is SelectAttribute.value:
+            matchers = json.dumps([{"value": s} for s in values])
+        elif attribute is SelectAttribute.label:
+            matchers = json.dumps([{"label": s} for s in values])
+        elif attribute is SelectAttribute.index:
+            matchers = json.dumps([{"index": int(s)} for s in values])
+        with self.playwright.grpc_channel() as stub:
+            response = stub.SelectOption(
+                Request().SelectElementSelector(selector=selector, matcherJson=matchers)
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent"])
+    def deselect_options(self, selector: str):
+        """Deselects all options from select element found by ``selector``.
+
+        ``selector`` <str> Selector of the select tag. **Required**
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.DeselectOption(Request().ElementSelector(selector=selector))
+            logger.debug(response.log)
+
+    def _fill_text(self, selector: str, text: str, log_response: bool = True):
+        with self.playwright.grpc_channel() as stub:
+            response = stub.FillText(Request().FillText(selector=selector, text=text))
+            if log_response:
+                logger.debug(response.log)
+
+    def _type_text(
+        self,
+        selector: str,
+        text: str,
+        delay: str = "0 ms",
+        clear: bool = True,
+        log_response: bool = True,
+    ):
+        with self.playwright.grpc_channel() as stub:
+            delay_ms = timestr_to_millisecs(delay)
+            response = stub.TypeText(
+                Request().TypeText(
+                    selector=selector, text=text, delay=int(delay_ms), clear=clear
+                )
+            )
+            if log_response:
+                logger.debug(response.log)
+
+    @keyword(tags=["Setter", "PageContent", "EventHandler"])
+    def upload_file(self, path: str):
+        """ Upload file from ``path`` into next file chooser dialog on page.
+
+        ``path`` <str> Path to file to be uploaded.
+
+        Example use:
+
+        | Upload File    ${CURDIR}/test_upload_file
+        | Click          \\#file_chooser
+
+        """
+        p = Path(path)
+        p.resolve(strict=True)
+        with self.playwright.grpc_channel() as stub:
+            response = stub.UploadFile(Request().FilePath(path=str(p)))
+            logger.debug(response.log)
+
+    @keyword(tags=["PageContent", "EventHandler"])
+    def handle_alert(self, action: AlertAction, prompt_input: str = ""):
+        """ Handle next dialog on page with ``action``. Dialog can be any of alert,
+        beforeunload, confirm or prompt.
+
+            ``action`` < ``acceppt`` | ``dismiss`` > How to handle the alert. **Required**
+
+            ``prompt_input`` <str> The value to enter into prompt. Only valid if
+            ``action`` equals accept. Defaults to empty string.
+        """
+
+        with self.playwright.grpc_channel() as stub:
+            if prompt_input and action is not AlertAction.accept:
+                raise ValueError("prompt_input is only valid if action is 'accept'")
+            response = stub.HandleAlert(
+                Request().AlertAction(alertAction=action.name, promptInput=prompt_input)
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["VirtualMouse", "PageContent"])
+    def mouse_button(
+        self,
+        action: MouseButtonAction,
+        x: Optional[float] = None,
+        y: Optional[float] = None,
+        button: MouseButton = MouseButton.left,
+        clickCount: int = 1,
+        delay: int = 0,
+    ):
+        """ Click, hold a mouse button down or release it. Moving the mouse between holding down
+        and releasing it for example is possible.
+
+            ``action`` < ``click`` | ``up`` | ``down`` > Determines if it is a mouseclick, holding down a key or releasing it.
+
+            ``x`` <int> and ``y`` <int> Coordinates for a click only. Defaults to None.
+            **Required** if action is a click.
+
+            ``button`` < ``left``| ``right`` | ``middle`` > Defaults to ``left`` if invalid.
+
+            ``clickCount`` <int> Deterine how often shall be clicked. Defaults to 1.
+
+            ``delay`` <int> Delay in ms between the mousedown and mouseup event. Can only be set if the action is click.
+        """
+        with self.playwright.grpc_channel() as stub:
+            body: MouseOptionsDict = {}
+            if delay and action is not MouseButtonAction.click:
+                raise ValueError("Delay is only valid on a mouse click")
+            if action is MouseButtonAction.down or action is MouseButtonAction.up:
+                if x or y:
+                    raise ValueError(
+                        "Coordinates are not valid on MouseAction.up or MouseAction.down"
+                    )
+                body = {
+                    "options": {
+                        "button": button.name,
+                        "clickCount": clickCount,
+                        "delay": delay,
+                    }
+                }
+            else:
+                body = {}
+                if x:
+                    body["x"] = float(x)
+                if y:
+                    body["y"] = float(y)
+                body["options"] = {
+                    "button": button.name,
+                    "clickCount": clickCount,
+                    "delay": delay,
+                }
+
+            response = stub.MouseButton(
+                Request().MouseButtonOptions(action=action.name, json=json.dumps(body))
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["VirtualMouse", "PageContent"])
+    def mouse_move(self, x: float, y: float, steps: int = 1):
+        """ Instead of selectors command mouse with coordinates.
+            The Click commands will leave the virtual mouse on the specified coordinates.
+
+            ``x`` <float> ``y`` <float> are absolute coordinates starting at the top left
+            of the page.
+
+            ``steps`` <int> Number of intermediate steps for the mouse event.
+        """
+        with self.playwright.grpc_channel() as stub:
+            body: MouseOptionsDict = {"x": x, "y": y, "options": {"steps": steps}}
+            response = stub.MouseMove(Request().Json(body=json.dumps(body)))
+            logger.debug(response.log)
+
+    @keyword(tags=["VirtualKeyboard", "PageContent"])
+    def keyboard_key(self, action: KeyAction, key: str):
+        """ Press a keyboard key on the virtual keyboard or set a key up or down.
+
+        ``action`` < ``up`` | ``down`` | ``press`` > Determine whether the key should be released,
+        hold or pressed. ``down`` or ``up`` are useful for combinations i.e. with Shift.
+        **Required**
+
+        ``key`` <str> The key to be pressed. An example of valid 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.
+
+        Useful keys for ``down`` and ``up`` for example are:
+
+        ``Shift``, ``Control``, ``Alt``, ``Meta``, ``ShiftLeft``
+
+        Example excecution:
+        | Keyboard Key    press    S
+        | Keyboard Key    down     Shift
+        | Keyboard Key    press    ArrowLeft
+        | Keyboard Key    press    Delete
+        | Keyboard Key    up       Shift
+
+        Note: Capital letters don't need to be written by the help of Shift. You can type them in directly.
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.KeyboardKey(
+                Request().KeyboardKeypress(action=action.name, key=key)
+            )
+            logger.debug(response.log)
+
+    @keyword(tags=["VirtualKeyboard", "PageContent"])
+    def keyboard_input(self, action: KeyboardInputAction, input: str, delay=0):
+        """ Input text into page with virtual keyboard.
+
+            ``action`` < ``insertText`` | ``type`` > **Required**
+
+                - ``insertText`` Dispatches only input event, does not emit the keydown, keyup or keypress events.
+
+                - ``type`` Sends a keydown, keypress/input, and keyup event for each character in the text.
+
+            ``input`` <str> The inputstring to be typed. No special keys possible. **Required**
+
+            Note: To press a special key, like Control or ArrowDown, use keyboard.press.
+            Modifier keys DO NOT effect these methods. For testing modifier effects use single key
+            presses with ``Keyboard Key  press``
+
+        """
+        with self.playwright.grpc_channel() as stub:
+            response = stub.KeyboardInput(
+                Request().KeyboardInputOptions(
+                    action=action.name, input=input, delay=delay
+                )
+            )
+            logger.debug(response.log)
diff --git a/Browser/keywords/network.py b/Browser/keywords/network.py
index b07f1cf15..7fc0fc5af 100644
--- a/Browser/keywords/network.py
+++ b/Browser/keywords/network.py
@@ -45,7 +45,7 @@ def http(
 
         Accepts the following arguments:
           - ``url`` <str> The request url, e.g. ``/api/foo``.
-          - ``method`` <GET|POST|PUT|PATCH|DELETE|HEAD> The HTTP method for the request. Defaults to GET.
+          - ``method`` < ``GET`` | ``POST`` | ``PUT`` | ``PATCH`` | ``DELETE`` | ``HEAD`` > The HTTP method for the request. Defaults to GET.
           - ``body`` <str> The request body. GET requests cannot have a body. If the body can be parsed as JSON,
           the ``Content-Type`` header for the request will be automatically set to ``application/json``.
           Defaults to None.
@@ -62,9 +62,9 @@ def http(
         Here's an example of using Robot Framework dictionary variables and extended variable syntax to
         do assertions on the response object:
 
-        | &{res}=          |  HTTP                    |  /api/endpoint |
-        | Should Be Equal  |  ${res.status}           |  200           |
-        | Should Be Equal  |  ${res.body.some_field}  |  some value    |
+        | &{res}=             HTTP                       /api/endpoint
+        | Should Be Equal     ${res.status}              200
+        | Should Be Equal     ${res.body.some_field}     some value
 
         """
         if headers is None:
diff --git a/Browser/keywords/playwright_state.py b/Browser/keywords/playwright_state.py
old mode 100644
new mode 100755
index 46ccaca2b..8175cfb81
--- a/Browser/keywords/playwright_state.py
+++ b/Browser/keywords/playwright_state.py
@@ -47,7 +47,7 @@ def open_browser(
 
         ``url`` <str> Navigates to URL if provided. Defaults to None.
 
-        ``browser`` <firefox|chromium|webkit> Specifies which browser to use. The
+        ``browser`` < ``firefox`` | ``chromium`` | ``webkit`` > Specifies which browser to use. The
         supported browsers are listed in the table below. The browser names
         are case-sensitive.
         |   = Value =     |        = Name(s) =                                   |
@@ -65,6 +65,11 @@ def open_browser(
     @keyword(tags=["BrowserControl"])
     def close_browser(self, browser: str = "CURRENT"):
         """Closes the current browser. Activated browser is set to first active browser.
+        Closes all context and pages belonging to this browser.
+
+        ``browser`` < ``CURRENT`` | ``ALL`` |str> If value is not ``CURRENT``
+        it should be an int referencing the id of the browser to be closed.
+        If ``ALL`` is provided `Close All Browsers` is executed.
         """
         with self.playwright.grpc_channel() as stub:
             if browser == "ALL":
@@ -78,17 +83,22 @@ def close_browser(self, browser: str = "CURRENT"):
 
     @keyword(tags=["BrowserControl"])
     def close_all_browsers(self):
-        """Closes all open browsers."""
+        """Closes all open browsers, contexts and pages."""
         with self.playwright.grpc_channel() as stub:
             response = stub.CloseAllBrowsers(Request().Empty())
             logger.info(response.log)
 
     @keyword(tags=["BrowserControl"])
     def close_context(self, context: str = "CURRENT", browser: str = "CURRENT"):
-        """Closes the current Context. Activated context is set to first active context.
+        """Closes a Context. Activated context is set to first active context.
+        Closes pages belonging to this context.
+
+        ``context`` < ``CURRENT`` | ``ALL`` |str> Close context with specified id. If ``ALL``
+        is passed, all contexts of the specified browser are closed. Defaults to CURRENT.
 
-            ``browser`` Close context in specified browser. If value is not "CURRENT" it should be an int referencing the id of the browser where to close context
-            ``context`` Close context with specified id
+        ``browser`` < ``CURRENT`` | ``ALL`` |str> Close context in specified browser. If value is not "CURRENT"
+        it should be an int referencing the id of the browser where to close context.
+        If ALL is passed, all contexts of the browser will be closed.
         """
         with self.playwright.grpc_channel() as stub:
             self._correct_browser(browser)
@@ -104,7 +114,21 @@ def close_context(self, context: str = "CURRENT", browser: str = "CURRENT"):
     def close_page(
         self, page: str = "CURRENT", context: str = "CURRENT", browser: str = "CURRENT"
     ):
-        """Closes the ``page`` in ``context`` in ``browser``. Defaults to current for all three. Activated page is set to first active page."""
+        # Add to page if ALL is implemented: If ALL is passed, all pages of the context will be closed.
+        """Closes the ``page`` in ``context`` in ``browser``. Defaults to current for all three.
+        Activated page is set to first active page.
+
+        ``page`` < ``CURRENT`` | ``ALL`` |str> Id of the page to close. If value is not "CURRENT"
+        it should be an int referencing the id of the context where to close page.
+        If ``ALL`` is passed, all pages of the given context are closed. Defaults to CURRENT.
+
+        ``context`` < ``CURRENT`` | ``ALL`` |str> Id of the context that belongs to the page to be closed.
+        If ``ALL`` is passed, the requested pages of all contexts are closed. Defaults to CURRENT.
+
+        ``browser`` < ``CURRENT`` | ``ALL`` |str> Id of the browser that belongs to the page to be closed.
+        If ``ALL`` is passed, the requested pages depending of the context of all browsers are closed.
+        Defaults to CURRENT.
+        """
         with self.playwright.grpc_channel() as stub:
             self._correct_browser(browser)
             self._correct_context(context)
@@ -139,9 +163,44 @@ def new_browser(
 
         Returns a stable identifier for the created browser.
 
-        A Browser is the Playwright object that controls a single Browser process.
-        See [https://github.com/microsoft/playwright/blob/master/docs/api.md#browsertypelaunchoptions |Playwright browserType.launch]
-        for a full list of supported options.
+        ``browser`` <chromium|firefox|webkit> Opens the specified browser. Defaults to chromium.
+
+        ``headless`` <bool> Set to False if you want a GUI. Defaults to False.
+
+        ``executablePath`` <str> Path to a browser executable to run instead of the bundled one.
+        If executablePath is a relative path, then it is resolved relative to current working
+        directory. Note that Playwright only works with the bundled Chromium, Firefox or
+        WebKit, use at your own risk. Defaults to None.
+
+        ``args`` <List<str>> Additional arguments to pass to the browser instance. The list of
+        Chromium flags can be found [http://peter.sh/experiments/chromium-command-line-switches/ | here].
+        Defaults to None.
+
+        ``ignoreDefaultArgs`` <List<str>> If an array is given, then filters out the given default arguments.
+        Defaults to None.
+
+        ``proxy`` <Dict> Network proxy settings.
+        - server <string> Proxy to be used for all requests. HTTP and SOCKS proxies are supported, for example ``http://myproxy.com:3128`` or ``socks5://myproxy.com:3128``. Short form ``myproxy.com:3128`` is considered an HTTP proxy.
+        - bypass <string> Optional coma-separated domains to bypass proxy, for example ``".com, chromium.org, .domain.com"``.
+        - username <string> Optional username to use if HTTP proxy requires authentication.
+        - password <string> Optional password to use if HTTP proxy requires authentication.
+
+        ``downloadsPath`` <str> If specified, accepted downloads are downloaded into this folder.
+        Otherwise, temporary folder is created and is deleted when browser is closed.
+
+        ``handleSIGINT`` <bool> Close the browser process on Ctrl-C. Defaults to True.
+
+        ``handleSIGTERM`` <bool> Close the browser process on SIGTERM. Defaults to True.
+
+        ``handleSIGHUP`` <bool> Close the browser process on SIGHUP. Defaults to True.
+
+        ``timeout`` <int> Maximum time in milliseconds to wait for the browser instance to start. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
+
+        ``env`` <Dict<str, str|int|bool>> Specify environment variables that will be visible to the browser. Defaults to None.
+
+        ``devtools`` <bool> Chromium-only Whether to auto-open a Developer Tools panel for each tab. If this option is true, the headless option will be set false.
+
+        ``slowMo`` <int> Slows down Playwright operations by the specified amount of milliseconds. Useful so that you can see what is going on. Defaults to no delay.
         """
         params = locals_to_params(locals())
         if timeout:
@@ -213,7 +272,7 @@ def new_context(
         Defaults to True.
 
         ``timezoneId`` <str> Changes the timezone of the context.
-        See [https://source.chromium.org/chromium/chromium/deps/icu.git/+/faee8bc70570192d82d2978a71e2a615788597d1:source/data/misc/metaZones.txt?originalUrl=https:%2F%2Fcs.chromium.org%2F|ICU’s metaZones.txt]
+        See [https://source.chromium.org/chromium/chromium/deps/icu.git/+/faee8bc70570192d82d2978a71e2a615788597d1:source/data/misc/metaZones.txt | ICU’s metaZones.txt]
         for a list of supported timezone IDs.
 
         ``geolocation`` <dict> Sets the geolocation. No location is set be default.
@@ -226,8 +285,8 @@ def new_context(
         Locale will affect ``navigator.language`` value, ``Accept-Language`` request header value
         as well as number and date formatting rules.
 
-        ``permissions`` <list[str]> A list of permissions to grant to all pages in this context.
-        See [https://github.com/microsoft/playwright/blob/master/docs/api.md#browsercontextgrantpermissionspermissions-options|grantPermissions] for more details.
+        ``permissions`` <list<str>> A list of permissions to grant to all pages in this context.
+        See [https://github.com/microsoft/playwright/blob/master/docs/api.md#browsercontextgrantpermissionspermissions-options | grantPermissions] for more details.
 
         ``extraHTTPHeaders`` <dict[str, str]> A dictionary containing additional HTTP headers
         to be sent with every request. All header values must be strings.
@@ -296,9 +355,13 @@ def switch_browser(self, index: int):
     @keyword(tags=["BrowserControl"])
     def switch_context(self, index: int, browser: str = "CURRENT"):
         """ Switches the active BrowserContext to another open context.
-            Returns a stable identifier for the previous context.
+        Returns a stable identifier for the previous context.
+
+        ``index`` <int> Index id of the context to be changed to. Starting at 0. **Required**
 
-            ``index`` <int> Index id of the context to be changed to. Starting at 0. **Required**
+        ``browser`` < ``CURRENT`` | ``ALL`` |str> Switch context in specified browser. If value is not "CURRENT"
+        it should be an int referencing the id of the browser where to switch context.
+        If ALL is passed, the contexts of the browser will be closed.
         """
         with self.playwright.grpc_channel() as stub:
             self._correct_browser(browser)
@@ -311,10 +374,18 @@ def switch_page(
         self, index: int, context: str = "CURRENT", browser: str = "CURRENT"
     ):
         """Switches the active browser page to another open page by ``index``.
-            Returns a stable identifier for the previous page.
-            Newly opened pages get appended to the end of the list.
+        Returns a stable identifier for the previous page.
+        Newly opened pages get appended to the end of the list.
+
+        ``index`` <int> Index id of the page to be changed to. Starting at 0. **Required**
+
+        ``context`` < ``CURRENT`` | ``ALL`` |str> Switch page in specified context. If value is not "CURRENT"
+        it should be an int referencing the id of the context where to switch page.
+        If ALL is passed, the pages of all contexts switch.
 
-            ``index`` <int> Index id of the page to be changed to. Starting at 0. **Required**
+        ``browser`` < ``CURRENT`` | ``ALL`` |str> Switch page in specified browser. If value is not "CURRENT"
+        it should be an int referencing the id of the browser where to switch page.
+        If ALL is passed, the page of all browsers depending on the context switch.
         """
         with self.playwright.grpc_channel() as stub:
             self._correct_browser(browser)
diff --git a/Browser/keywords/promises.py b/Browser/keywords/promises.py
index 4cb728edc..933a7053f 100644
--- a/Browser/keywords/promises.py
+++ b/Browser/keywords/promises.py
@@ -20,9 +20,9 @@ def promise_to(self, kw: str, *args):
         ``kw`` <str> Keyword that will work async on background.
 
         Example:
-        | ${promise}=  |  Promise To         |  Wait For Response  |  matcher=  |  timeout=3s |
-        | Click        |  \\#delayed_request |                     |            |             |
-        | ${body}=     |  Wait For           |  ${promise}         |            |             |
+        | ${promise}=     Promise To            Wait For Response     matcher=     timeout=3
+        | Click           \\#delayed_request
+        | ${body}=        Wait For              ${promise}
         """
         browser_lib = EXECUTION_CONTEXTS.current.namespace._kw_store.get_library(
             self.library
@@ -47,9 +47,9 @@ def wait_for(self, *promises: Future):
         ``promises`` *Work in progress*
 
         Example:
-        | ${promise}=  |  Promise To         |  Wait For Response  |  matcher=  |  timeout=3s |
-        | Click        |  \\#delayed_request |                     |            |             |
-        | ${body}=     |  Wait For           |  ${promise}         |            |             |
+        | ${promise}=     Promise To            Wait For Response     matcher=     timeout=3
+        | Click           \\#delayed_request
+        | ${body}=        Wait For              ${promise}
         """
         self.unresolved_promises -= {*promises}
         if len(promises) == 1:
diff --git a/Browser/keywords/waiter.py b/Browser/keywords/waiter.py
index 220bc0003..d5a06a01f 100644
--- a/Browser/keywords/waiter.py
+++ b/Browser/keywords/waiter.py
@@ -103,12 +103,12 @@ def wait_for_function(
         ``polling`` <str> Default polling value of "raf" polls in a callback for ``requestAnimationFrame``.
         Any other value for polling will be parsed as a robot framework time for interval between polls.
 
-        ``timeout`` <str> (optional) uses default timeout of 10 seconds if not set.
+        ``timeout`` <str> Uses default timeout of 10 seconds if not set.
 
         Example usage:
-        | ${promise}  |  Promise To    |  Wait For Function  |  element => element.style.width=="100%"  |  selector=\\#progress_bar  |  timeout=4s |
-        | Click       | \\#progress_bar |
-        | Wait For    | ${promise}     |
+        | ${promise}    Promise To      Wait For Function    element => element.style.width=="100%"    selector=\\#progress_bar    timeout=4s
+        | Click         \\#progress_bar
+        | Wait For      ${promise}
         """
         with self.playwright.grpc_channel() as stub:
             options: Dict[str, int] = {}
@@ -135,11 +135,11 @@ def wait_for_download(self, saveAs: str = ""):
             ``saveAs`` <str> Filename to save as. File will also temporarily be saved in playwright context's default download location.
 
             Example usage:
-            | New Context    | acceptDownloads=True
-            | New Page       | ${LOGIN_URL}
-            | ${dl_promise}  | Promise To  Wait For Download
-            | Click          | \\#file_download
-            | ${file_path}=  | Wait For  ${dl_promise}
+            | New Context      acceptDownloads=True
+            | New Page         ${LOGIN_URL}
+            | ${dl_promise}    Promise To  Wait For Download
+            | Click            \\#file_download
+            | ${file_path}=    Wait For  ${dl_promise}
         """
         with self.playwright.grpc_channel() as stub:
             if not saveAs:
diff --git a/atest/test/02_Content_Keywords/click_with_options.robot b/atest/test/02_Content_Keywords/click_with_options.robot
index efb304175..6f8f6f317 100644
--- a/atest/test/02_Content_Keywords/click_with_options.robot
+++ b/atest/test/02_Content_Keywords/click_with_options.robot
@@ -6,7 +6,11 @@ Test Setup        New Page    ${LOGIN_URL}
 Click Count
     Click With Options    \#clickWithOptions    click_count=10
     Get Text    \#click_count    ==    10
-# When delay is set raises Could not find element with selector `#clickWithOptions` within timeout. error
+
+Click Count with Delay
+    [Tags]    Not-Implemented
+    Click With Options    \#clickWithOptions    delay=100    click_count=10
+    Get Text    \#click_count    ==    10
 
 Delay Click
     [Tags]    Not-Implemented
@@ -26,14 +30,12 @@ Left Right and Middle Click
     Get Text    \#mouse_button    ==    middle
     Click With Options    \#clickWithOptions    left
     Get Text    \#mouse_button    ==    left
-# Invalid usage since coordinates are usually return as centre.
-# When we go to x=1, y=1 we are at top left of element, not 1, 1 pixels off the centre
 
 Click with Coordinates
     [Tags]    Not-Implemented
-    Click With Options    \#clickWithOptions
-    ${x}=    Get Text    \#coordinatesX
-    ${y}=    Get Text    \#coordinatesY
+    ${xy}    Get Boundingbox    \#clickWithOptions    x    y
+    ${x}    Evaluate    ${xy}[x]+1
+    ${y}    Evaluate    ${xy}[y]+1
     Click With Options    \#clickWithOptions    position_x=1    position_y=1
-    Get Text    \#coordinatesX    validate    int(${x}+1)==int(value)
-    Get Text    \#coordinatesY    validate    int(${y}+1)==int(value)
+    Get Text    \#coordinatesX    validate    int(${x})==int(value)
+    Get Text    \#coordinatesY    validate    int(${y})==int(value)
diff --git a/atest/test/02_Content_Keywords/virtual_mouse.robot b/atest/test/02_Content_Keywords/virtual_mouse.robot
index b5c7da8d3..282ca4469 100644
--- a/atest/test/02_Content_Keywords/virtual_mouse.robot
+++ b/atest/test/02_Content_Keywords/virtual_mouse.robot
@@ -15,6 +15,19 @@ Move In Circle
     Mouse Move    400    0
     Mouse Move    0    0
 
+Draggable Test
+    [Tags]    Not-Implemented
+    ${xy}=    Get Boundingbox    \#draggable    x    y
+    # evaluate end coordinates
+    ${x}    Evaluate    ${xy}[x]+400
+    ${y}    Evaluate    ${xy}[y]+400
+    Mouse Button    down    ${xy}[x]    ${xy}[y]
+    Mouse Button    up    ${x}    ${y}
+    # just do a random move to make sure the element is not stuck to mouse any more
+    Mouse Move    0    0
+    Get Text    \#dragX    ==    400
+    Get Text    \#dragY    ==    400
+
 Click Count
     ${x}=    Get Boundingbox    \#clickWithOptions    x
     ${y}=    Get Boundingbox    \#clickWithOptions    y
diff --git a/node/dynamic-test-app/src/app.tsx b/node/dynamic-test-app/src/app.tsx
index 63a77957f..645a7fe97 100644
--- a/node/dynamic-test-app/src/app.tsx
+++ b/node/dynamic-test-app/src/app.tsx
@@ -1,6 +1,6 @@
-import React, { ChangeEvent, FocusEvent, useRef, useState } from 'react';
-import Draggable from 'react-draggable';
 import { DraggableData, DraggableEvent } from 'react-draggable';
+import Draggable from 'react-draggable';
+import React, { ChangeEvent, FocusEvent, useRef, useState } from 'react';
 
 function goesInvisible(event: React.MouseEvent<HTMLButtonElement>) {
     event.persist();
@@ -79,29 +79,29 @@ function testPrompt(promptResultElement: React.RefObject<HTMLElement>) {
 
 function DraggableDiv() {
     const onControlledDrag = (e: DraggableEvent, position: DraggableData) => {
-        const {x, y} = position;
-        setControlledPosition({x, y});
+        const { x, y } = position;
+        setControlledPosition({ x, y });
     };
-    const [controlledPosition, setControlledPosition] = useState({x: 0, y: 0});
-    return <Draggable position={controlledPosition} onDrag={onControlledDrag} >
-        <div className="box">
-            My position can be changed programmatically. <br />
-            I have a drag handler to sync state.
-            <div>
-                <div>x ({controlledPosition.x})</div>
-            </div>
-            <div>
-                <div> y ({controlledPosition.y})</div>
+    const [controlledPosition, setControlledPosition] = useState({ x: 0, y: 0 });
+    return (
+        <Draggable position={controlledPosition} onDrag={onControlledDrag}>
+            <div className="box" id="draggable">
+                My position can be changed programmatically. <br />I have a drag handler to sync state.
+                <div>
+                    x<div id="dragX">{controlledPosition.x}</div>
+                </div>
+                <div>
+                    y<div id="dragY">{controlledPosition.y}</div>
+                </div>
             </div>
-        </div>
-    </Draggable>
+        </Draggable>
+    );
 }
 
 export default function Site() {
     const username = useRef('');
     const password = useRef('');
 
-
     const [submit, setSubmit] = useState(false);
     const uploadResult = React.createRef<HTMLDivElement>();
     const promptResult = React.createRef<HTMLDivElement>();
@@ -250,7 +250,6 @@ export default function Site() {
                 </a>
                 <ProgressBar />
                 <DraggableDiv />
-                
             </>
         );
     }