wavexis 2.3.2__tar.gz → 2.3.3__tar.gz

{wavexis-2.3.2 → wavexis-2.3.3}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.3.3 — 2026-07-07
+
+### Added
+
+- Shadow DOM support: `shadow_click`, `shadow_fill`, `shadow_eval` in both CDP and BiDi backends
+- `wavexis shadow click/fill/eval` CLI command with `--selectors` (comma-separated piercing chain)
+- `_build_shadow_pierce_js` helper generates JS that traverses `shadowRoot` boundaries
+- Auto-waiting inside shadow DOM via `_wait_for_element_in_shadow` with polling and configurable timeout
+- `--no-wait` flag to skip auto-waiting for shadow interactions
+- Events dispatched with `composed: true` to cross shadow boundaries
+
 ## v2.3.2 — 2026-07-07
 
 ### Added

{wavexis-2.3.2 → wavexis-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavexis
-Version: 2.3.2
+Version: 2.3.3
 Summary: Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download
 Project-URL: Homepage, https://github.com/MathiasPaulenko/wavexis
 Project-URL: Repository, https://github.com/MathiasPaulenko/wavexis

{wavexis-2.3.2 → wavexis-2.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wavexis"
-version = "2.3.2"
+version = "2.3.3"
 description = "Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download"
 readme = "README.md"
 license = { text = "MIT" }

{wavexis-2.3.2 → wavexis-2.3.3}/tests/unit/test_backend_manager.py

@@ -268,6 +268,24 @@ class DummyBackend(AbstractBackend):
         """Iframe fill."""
         pass
 
+    async def shadow_eval(
+        self, selectors: list[str], expression: str, await_promise: bool = False
+    ) -> object:
+        """Shadow eval."""
+        return None
+
+    async def shadow_click(
+        self, selectors: list[str], auto_wait: bool = True
+    ) -> None:
+        """Shadow click."""
+        pass
+
+    async def shadow_fill(
+        self, selectors: list[str], value: str, auto_wait: bool = True
+    ) -> None:
+        """Shadow fill."""
+        pass
+
     async def throttle_network(self, params: object) -> None:
         """Throttle network."""
         pass

{wavexis-2.3.2 → wavexis-2.3.3}/tests/unit/test_manager.py

@@ -269,6 +269,13 @@ class FakeBackend(AbstractBackend):
         """Iframe click."""
     async def iframe_fill(self, iframe_selector, selector, value, auto_wait=True):
         """Iframe fill."""
+    async def shadow_eval(self, selectors, expression, await_promise=False):
+        """Shadow eval."""
+        return None
+    async def shadow_click(self, selectors, auto_wait=True):
+        """Shadow click."""
+    async def shadow_fill(self, selectors, value, auto_wait=True):
+        """Shadow fill."""
 
 
 class TestBackendManager:

wavexis-2.3.3/tests/unit/test_shadow.py

@@ -0,0 +1,232 @@
+"""Unit tests for Shadow DOM support — shadow_eval, shadow_click, shadow_fill."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from wavexis.exceptions import ElementNotFoundError
+
+
+def _make_cdp_backend() -> Any:
+    """Create a CDPBackend with mocked session."""
+    from wavexis.backend.cdp import CDPBackend
+
+    backend = CDPBackend()
+    backend._session = MagicMock()
+    backend._session.runtime = MagicMock()
+    backend._session.runtime.evaluate = AsyncMock(
+        return_value={"result": {"value": True}}
+    )
+    return backend
+
+
+def _make_bidi_backend() -> Any:
+    """Create a BiDiBackend with mocked client."""
+    from wavexis.backend.bidi import BiDiBackend
+
+    backend = BiDiBackend()
+    backend._client = MagicMock()
+    backend._context = MagicMock()
+    backend._client.script = MagicMock()
+    result = MagicMock()
+    result.value = True
+    backend._client.script.evaluate = AsyncMock(return_value=result)
+    return backend
+
+
+@pytest.mark.unit
+class TestShadowEval:
+    """Tests for shadow_eval in both backends."""
+
+    def test_cdp_shadow_eval_returns_value(self) -> None:
+        """Test CDP shadow_eval returns the evaluated value."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": 42}}
+        )
+        result = asyncio.run(
+            backend.shadow_eval(["my-component", "button"], "1 + 1")
+        )
+        assert result == 42
+
+    def test_cdp_shadow_eval_null_element_not_found(self) -> None:
+        """Test CDP shadow_eval returns None when element is not found."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": None}}
+        )
+        result = asyncio.run(
+            backend.shadow_eval(["missing", "button"], "this.textContent")
+        )
+        assert result is None
+
+    def test_bidi_shadow_eval_returns_value(self) -> None:
+        """Test BiDi shadow_eval returns the evaluated value."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = "hello"
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        result = asyncio.run(
+            backend.shadow_eval(["my-component", "button"], "this.textContent")
+        )
+        assert result == "hello"
+
+
+@pytest.mark.unit
+class TestShadowClick:
+    """Tests for shadow_click in both backends."""
+
+    def test_cdp_shadow_click_success(self) -> None:
+        """Test CDP shadow_click dispatches click inside shadow DOM."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": True}}
+        )
+        asyncio.run(backend.shadow_click(["my-component", "button"], auto_wait=False))
+        backend._session.runtime.evaluate.assert_called()
+
+    def test_cdp_shadow_click_element_not_found(self) -> None:
+        """Test CDP shadow_click raises ElementNotFoundError when element missing."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": False}}
+        )
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(backend.shadow_click(["missing", "btn"], auto_wait=False))
+
+    def test_bidi_shadow_click_success(self) -> None:
+        """Test BiDi shadow_click dispatches click inside shadow DOM."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = True
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        asyncio.run(backend.shadow_click(["my-component", "button"], auto_wait=False))
+        backend._client.script.evaluate.assert_called()
+
+    def test_bidi_shadow_click_element_not_found(self) -> None:
+        """Test BiDi shadow_click raises ElementNotFoundError when element missing."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = False
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(backend.shadow_click(["missing", "btn"], auto_wait=False))
+
+
+@pytest.mark.unit
+class TestShadowFill:
+    """Tests for shadow_fill in both backends."""
+
+    def test_cdp_shadow_fill_success(self) -> None:
+        """Test CDP shadow_fill sets value inside shadow DOM."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": True}}
+        )
+        asyncio.run(
+            backend.shadow_fill(["my-component", "input"], "test value", auto_wait=False)
+        )
+        backend._session.runtime.evaluate.assert_called()
+
+    def test_cdp_shadow_fill_element_not_found(self) -> None:
+        """Test CDP shadow_fill raises ElementNotFoundError when element missing."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": False}}
+        )
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(
+                backend.shadow_fill(["missing", "input"], "val", auto_wait=False)
+            )
+
+    def test_bidi_shadow_fill_success(self) -> None:
+        """Test BiDi shadow_fill sets value inside shadow DOM."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = True
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        asyncio.run(
+            backend.shadow_fill(["my-component", "input"], "test value", auto_wait=False)
+        )
+        backend._client.script.evaluate.assert_called()
+
+    def test_bidi_shadow_fill_element_not_found(self) -> None:
+        """Test BiDi shadow_fill raises ElementNotFoundError when element missing."""
+        backend = _make_bidi_backend()
+        result_mock = MagicMock()
+        result_mock.value = False
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        with pytest.raises(ElementNotFoundError):
+            asyncio.run(
+                backend.shadow_fill(["missing", "input"], "val", auto_wait=False)
+            )
+
+
+@pytest.mark.unit
+class TestShadowAutoWait:
+    """Tests for auto_wait in shadow operations."""
+
+    def test_cdp_shadow_click_auto_wait_false_skips_wait(self) -> None:
+        """Test that shadow_click with auto_wait=False skips _wait_for_element_in_shadow."""
+        backend = _make_cdp_backend()
+        call_order: list[str] = []
+
+        async def _mock_wait(selectors: list[str], timeout_ms: int = 30000) -> None:
+            call_order.append("wait")
+
+        backend._wait_for_element_in_shadow = _mock_wait  # type: ignore[assignment]
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": True}}
+        )
+
+        asyncio.run(backend.shadow_click(["my-component", "btn"], auto_wait=False))
+        assert "wait" not in call_order
+
+    def test_cdp_shadow_click_auto_wait_true_calls_wait(self) -> None:
+        """Test that shadow_click with auto_wait=True calls _wait_for_element_in_shadow."""
+        backend = _make_cdp_backend()
+        call_order: list[str] = []
+
+        async def _mock_wait(selectors: list[str], timeout_ms: int = 30000) -> None:
+            call_order.append("wait")
+
+        backend._wait_for_element_in_shadow = _mock_wait  # type: ignore[assignment]
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": True}}
+        )
+
+        asyncio.run(backend.shadow_click(["my-component", "btn"], auto_wait=True))
+        assert "wait" in call_order
+
+
+@pytest.mark.unit
+class TestBuildShadowPierceJs:
+    """Tests for _build_shadow_pierce_js helper."""
+
+    def test_single_selector(self) -> None:
+        """Test JS generation for a single selector (no shadow piercing)."""
+        from wavexis.backend.cdp import CDPBackend
+
+        js = CDPBackend._build_shadow_pierce_js(["#my-element"])
+        assert "document.querySelector" in js
+        assert "shadowRoot" not in js
+
+    def test_nested_selectors(self) -> None:
+        """Test JS generation for nested shadow piercing."""
+        from wavexis.backend.cdp import CDPBackend
+
+        js = CDPBackend._build_shadow_pierce_js(["my-component", "inner", "button"])
+        assert js.count("shadowRoot") == 4
+        assert "inner" in js
+        assert "button" in js
+
+    def test_selector_escaping(self) -> None:
+        """Test that single quotes in selectors are escaped."""
+        from wavexis.backend.cdp import CDPBackend
+
+        js = CDPBackend._build_shadow_pierce_js(["[data-test='foo']"])
+        assert "\\'" in js

{wavexis-2.3.2 → wavexis-2.3.3}/wavexis/__init__.py

@@ -1,3 +1,3 @@
 """wavexis — CLI de automatización de navegador."""
 
-__version__ = "2.3.2"
+__version__ = "2.3.3"

{wavexis-2.3.2 → wavexis-2.3.3}/wavexis/backend/base.py

@@ -323,6 +323,45 @@ class AbstractBackend(ABC):
             auto_wait: If True, wait for element to be visible before filling.
         """
 
+    # ── Shadow DOM ──────────────────────────────────────────
+
+    @abstractmethod
+    async def shadow_eval(
+        self, selectors: list[str], expression: str, await_promise: bool = False
+    ) -> Any:
+        """Evaluate a JavaScript expression inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+                selectors[0] is in the main document, selectors[1] in
+                selectors[0].shadowRoot, and so on.
+            expression: JavaScript expression to evaluate in the shadow context.
+            await_promise: Whether to await a returned Promise.
+        """
+
+    @abstractmethod
+    async def shadow_click(
+        self, selectors: list[str], auto_wait: bool = True
+    ) -> None:
+        """Click an element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            auto_wait: If True, wait for element to be visible before clicking.
+        """
+
+    @abstractmethod
+    async def shadow_fill(
+        self, selectors: list[str], value: str, auto_wait: bool = True
+    ) -> None:
+        """Fill an input element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            value: Value to set in the input field.
+            auto_wait: If True, wait for element to be visible before filling.
+        """
+
     # ── Network advanced ───────────────────────────────────
 
     @abstractmethod

{wavexis-2.3.2 → wavexis-2.3.3}/wavexis/backend/bidi.py

@@ -1128,6 +1128,135 @@ class BiDiBackend(AbstractBackend):
         if not result_value:
             raise ElementNotFoundError(selector)
 
+    # ── Shadow DOM ──────────────────────────────────────────
+
+    @staticmethod
+    def _build_shadow_pierce_js(selectors: list[str]) -> str:
+        """Build JS that pierces shadow boundaries via a selector chain."""
+        escaped = [s.replace("'", "\\'") for s in selectors]
+        parts = [f"var el=document.querySelector('{escaped[0]}')"]
+        for sel in escaped[1:]:
+            parts.append(
+                f"if(!el||!el.shadowRoot)return null;"
+                f"el=el.shadowRoot.querySelector('{sel}')"
+            )
+        parts.append("return el")
+        body = ";".join(parts)
+        return f"(function(){{{body};}})()"
+
+    async def shadow_eval(
+        self, selectors: list[str], expression: str, await_promise: bool = False
+    ) -> Any:
+        """Evaluate a JavaScript expression inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            expression: JavaScript expression to evaluate in the shadow context.
+            await_promise: Whether to await a returned Promise.
+
+        Returns:
+            The evaluation result value.
+        """
+        client = self._require_client()
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        escaped_expr = expression.replace("\\", "\\\\").replace("'", "\\'")
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return null;"
+            f"return (function(){{{escaped_expr}}}).call(el);}})()"
+        )
+        result = await client.script.evaluate(
+            self._context, js, await_promise=await_promise
+        )
+        if hasattr(result, "value"):
+            return result.value
+        return result
+
+    async def _wait_for_element_in_shadow(
+        self, selectors: list[str], timeout_ms: int = 30000
+    ) -> None:
+        """Wait for an element inside a shadow DOM tree to exist and be visible.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            timeout_ms: Maximum wait time in milliseconds.
+
+        Raises:
+            WaitTimeoutError: If the element is not found within the timeout.
+        """
+        import asyncio as _asyncio
+        import time as _time
+
+        client = self._require_client()
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"var rect=el.getBoundingClientRect();"
+            f"return rect.width>0&&rect.height>0;}})()"
+        )
+        deadline = _time.monotonic() + timeout_ms / 1000
+        while _time.monotonic() < deadline:
+            result = await client.script.evaluate(self._context, js)
+            value = getattr(result, "value", None)
+            if value is True or value == "true":
+                return
+            await _asyncio.sleep(0.1)
+        raise WaitTimeoutError("selector", timeout_ms)
+
+    async def shadow_click(
+        self, selectors: list[str], auto_wait: bool = True
+    ) -> None:
+        """Click an element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            auto_wait: If True, wait for element to be visible before clicking.
+        """
+        client = self._require_client()
+        if auto_wait:
+            await self._wait_for_element_in_shadow(selectors)
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"el.scrollIntoView({{block:'center',behavior:'instant'}});"
+            f"el.dispatchEvent(new MouseEvent('click',{{bubbles:true,composed:true}}));"
+            f"return true;}})()"
+        )
+        result = await client.script.evaluate(self._context, js)
+        result_value = getattr(result, "value", None)
+        if not result_value:
+            raise ElementNotFoundError(" -> ".join(selectors))
+
+    async def shadow_fill(
+        self, selectors: list[str], value: str, auto_wait: bool = True
+    ) -> None:
+        """Fill an input element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            value: Value to set in the input field.
+            auto_wait: If True, wait for element to be visible before filling.
+        """
+        client = self._require_client()
+        if auto_wait:
+            await self._wait_for_element_in_shadow(selectors)
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        escaped_val = value.replace("\\", "\\\\").replace("'", "\\'")
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"el.focus();el.value='{escaped_val}';"
+            f"el.dispatchEvent(new Event('input',{{bubbles:true,composed:true}}));"
+            f"el.dispatchEvent(new Event('change',{{bubbles:true,composed:true}}));"
+            f"return true;}})()"
+        )
+        result = await client.script.evaluate(self._context, js)
+        result_value = getattr(result, "value", None)
+        if not result_value:
+            raise ElementNotFoundError(" -> ".join(selectors))
+
     async def block_requests(self, patterns: list[str]) -> None:
         """Block requests matching URL patterns (partial BiDi support)."""
         if self._client is None:

{wavexis-2.3.2 → wavexis-2.3.3}/wavexis/backend/cdp.py

@@ -1369,6 +1369,133 @@ class CDPBackend(AbstractBackend):
         if not result.get("result", {}).get("value"):
             raise ElementNotFoundError(selector)
 
+    # ── Shadow DOM ──────────────────────────────────────────
+
+    @staticmethod
+    def _build_shadow_pierce_js(selectors: list[str]) -> str:
+        """Build JS that pierces shadow boundaries via a selector chain.
+
+        Args:
+            selectors: List of CSS selectors. selectors[0] in document,
+                each subsequent selector in the previous element's shadowRoot.
+
+        Returns:
+            JavaScript IIFE that returns the final element or null.
+        """
+        escaped = [s.replace("'", "\\'") for s in selectors]
+        parts = [f"var el=document.querySelector('{escaped[0]}')"]
+        for sel in escaped[1:]:
+            parts.append(
+                f"if(!el||!el.shadowRoot)return null;"
+                f"el=el.shadowRoot.querySelector('{sel}')"
+            )
+        parts.append("return el")
+        body = ";".join(parts)
+        return f"(function(){{{body};}})()"
+
+    async def shadow_eval(
+        self, selectors: list[str], expression: str, await_promise: bool = False
+    ) -> Any:
+        """Evaluate a JavaScript expression inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            expression: JavaScript expression to evaluate in the shadow context.
+            await_promise: Whether to await a returned Promise.
+
+        Returns:
+            The evaluation result value.
+        """
+        session = self._require_session()
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        escaped_expr = expression.replace("\\", "\\\\").replace("'", "\\'")
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return null;"
+            f"return (function(){{{escaped_expr}}}).call(el);}})()"
+        )
+        result = await session.runtime.evaluate(js, await_promise=await_promise)
+        return result.get("result", {}).get("value")
+
+    async def _wait_for_element_in_shadow(
+        self, selectors: list[str], timeout_ms: int = 30000
+    ) -> None:
+        """Wait for an element inside a shadow DOM tree to exist and be visible.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            timeout_ms: Maximum wait time in milliseconds.
+
+        Raises:
+            WaitTimeoutError: If the element is not found within the timeout.
+        """
+        session = self._require_session()
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"var rect=el.getBoundingClientRect();"
+            f"return rect.width>0&&rect.height>0;}})()"
+        )
+        deadline = time.monotonic() + timeout_ms / 1000
+        while time.monotonic() < deadline:
+            result = await session.runtime.evaluate(js)
+            if result.get("result", {}).get("value") is True:
+                return
+            await asyncio.sleep(0.1)
+        raise WaitTimeoutError("selector", timeout_ms)
+
+    async def shadow_click(
+        self, selectors: list[str], auto_wait: bool = True
+    ) -> None:
+        """Click an element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            auto_wait: If True, wait for element to be visible before clicking.
+        """
+        session = self._require_session()
+        if auto_wait:
+            await self._wait_for_element_in_shadow(selectors)
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"el.scrollIntoView({{block:'center',behavior:'instant'}});"
+            f"el.dispatchEvent(new MouseEvent('click',{{bubbles:true,composed:true}}));"
+            f"return true;}})()"
+        )
+        result = await session.runtime.evaluate(js)
+        if not result.get("result", {}).get("value"):
+            raise ElementNotFoundError(" -> ".join(selectors))
+
+    async def shadow_fill(
+        self, selectors: list[str], value: str, auto_wait: bool = True
+    ) -> None:
+        """Fill an input element inside a shadow DOM tree.
+
+        Args:
+            selectors: List of CSS selectors piercing shadow boundaries.
+            value: Value to set in the input field.
+            auto_wait: If True, wait for element to be visible before filling.
+        """
+        session = self._require_session()
+        if auto_wait:
+            await self._wait_for_element_in_shadow(selectors)
+        pierce_js = self._build_shadow_pierce_js(selectors)
+        escaped_val = value.replace("\\", "\\\\").replace("'", "\\'")
+        js = (
+            f"(function(){{var el=({pierce_js});"
+            f"if(!el)return false;"
+            f"el.focus();el.value='{escaped_val}';"
+            f"el.dispatchEvent(new Event('input',{{bubbles:true,composed:true}}));"
+            f"el.dispatchEvent(new Event('change',{{bubbles:true,composed:true}}));"
+            f"return true;}})()"
+        )
+        result = await session.runtime.evaluate(js)
+        if not result.get("result", {}).get("value"):
+            raise ElementNotFoundError(" -> ".join(selectors))
+
     # ── Network advanced ───────────────────────────────────
 
     async def block_requests(self, patterns: list[str]) -> None: