fastled 1.3.38__py3-none-any.whl → 1.3.39__py3-none-any.whl

fastled/__version__.py

@@ -1,6 +1,6 @@
 # IMPORTANT! There's a bug in github which will REJECT any version update
 # that has any other change in the repo. Please bump the version as the
 # ONLY change in a commit, or else the pypi update and the release will fail.
-__version__ = "1.3.38"
+__version__ = "1.3.39"
 
 __version_url_latest__ = "https://raw.githubusercontent.com/zackees/fastled-wasm/refs/heads/main/src/fastled/__version__.py"

fastled/args.py

@@ -23,6 +23,8 @@ class Args:
     quick: bool
     release: bool
     ram_disk_size: str  # suffixed liked "25mb" or "1gb"
+    playwright: bool = False  # Use Playwright browser instead of system default
+    no_playwright_auto_resize: bool = False  # Disable Playwright auto-resize
     clear = False  # Force the last running container to be removed. Useful for benchmarking.
 
     @staticmethod
@@ -66,6 +68,12 @@ class Args:
         assert isinstance(
             args.release, bool
         ), f"expected bool, got {type(args.release)}"
+        assert isinstance(
+            args.playwright, bool
+        ), f"expected bool, got {type(args.playwright)}"
+        assert isinstance(
+            args.no_playwright_auto_resize, bool
+        ), f"expected bool, got {type(args.no_playwright_auto_resize)}"
 
         init: bool | str = False
         if args.init is None:
@@ -93,4 +101,6 @@ class Args:
             quick=args.quick,
             release=args.release,
             ram_disk_size=args.ram_disk_size,
+            playwright=args.playwright,
+            no_playwright_auto_resize=args.no_playwright_auto_resize,
         )

fastled/client_server.py

@@ -258,6 +258,8 @@ def run_client(
     ) = None,  # None means auto select a free port, http_port < 0 means no server.
     clear: bool = False,
     no_platformio: bool = False,
+    use_playwright: bool = False,
+    playwright_auto_resize: bool = True,
 ) -> int:
     has_checked_newer_version_yet = False
     compile_server: CompileServer | None = None
@@ -338,6 +340,8 @@ def run_client(
                 port=http_port,
                 compile_server_port=port,
                 open_browser=open_web_browser,
+                use_playwright=use_playwright,
+                playwright_auto_resize=playwright_auto_resize,
             )
         else:
             print("\nCompilation successful.")
@@ -560,6 +564,8 @@ def run_client_server(args: Args) -> int:
             profile=profile,
             clear=args.clear,
             no_platformio=no_platformio,
+            use_playwright=args.playwright,
+            playwright_auto_resize=not args.no_playwright_auto_resize,
         )
     except KeyboardInterrupt:
         return 1

fastled/open_browser.py

@@ -8,6 +8,29 @@ from pathlib import Path
 
 from fastled.server_flask import run_flask_in_thread
 
+try:
+    from fastled.playwright_browser import is_playwright_available, open_with_playwright
+
+    PLAYWRIGHT_AVAILABLE = is_playwright_available()
+except ImportError:
+    PLAYWRIGHT_AVAILABLE = False
+    open_with_playwright = None
+
+# Global reference to keep Playwright browser alive
+_playwright_browser_proxy = None
+
+
+def cleanup_playwright_browser() -> None:
+    """Clean up the Playwright browser on exit."""
+    global _playwright_browser_proxy
+    if _playwright_browser_proxy:
+        _playwright_browser_proxy.close()
+        _playwright_browser_proxy = None
+
+
+# Register cleanup function
+atexit.register(cleanup_playwright_browser)
+
 DEFAULT_PORT = 8089  # different than live version.
 PYTHON_EXE = sys.executable
 
@@ -78,6 +101,8 @@ def spawn_http_server(
     compile_server_port: int,
     port: int | None = None,
     open_browser: bool = True,
+    use_playwright: bool = False,
+    playwright_auto_resize: bool = True,
 ) -> Process:
 
     if port is not None and not is_port_free(port):
@@ -105,14 +130,38 @@ def spawn_http_server(
 
     wait_for_server(port)
     if open_browser:
-        print(f"Opening browser to http://localhost:{port}")
-        import webbrowser
-
-        webbrowser.open(
-            url=f"http://localhost:{port}",
-            new=1,
-            autoraise=True,
-        )
+        url = f"http://localhost:{port}"
+        if use_playwright and PLAYWRIGHT_AVAILABLE and open_with_playwright is not None:
+            print(f"Opening FastLED sketch in Playwright browser: {url}")
+            if playwright_auto_resize:
+                print(
+                    "Auto-resize enabled: Browser window will automatically adjust to content size"
+                )
+            global _playwright_browser_proxy
+            _playwright_browser_proxy = open_with_playwright(
+                url, auto_resize=playwright_auto_resize
+            )
+        elif use_playwright and not PLAYWRIGHT_AVAILABLE:
+            print(
+                "Playwright requested but not available. Install with: pip install fastled[full]"
+            )
+            print(f"Falling back to system browser: {url}")
+            import webbrowser
+
+            webbrowser.open(
+                url=url,
+                new=1,
+                autoraise=True,
+            )
+        else:
+            print(f"Opening browser to {url}")
+            import webbrowser
+
+            webbrowser.open(
+                url=url,
+                new=1,
+                autoraise=True,
+            )
     return proc
 
 

fastled/parse_args.py

@@ -35,12 +35,15 @@ FastLED WASM Compiler - Useful options:
   --profile             Enable profiling the C++ build system
   --update              Update the docker image for the wasm compiler
   --purge               Remove all FastLED containers and images
+  --playwright          Use Playwright browser (requires 'pip install fastled[full]')
+  --no-playwright-auto-resize  Disable automatic window resizing in Playwright
   --version             Show version information
   --help                Show detailed help
 Examples:
   fastled (will auto detect the sketch directory and prompt you)
   fastled my_sketch
   fastled my_sketch --web (compiles using the web compiler only)
+  fastled my_sketch --playwright (opens in Playwright browser)
   fastled --init Blink (initializes a new sketch directory with the Blink example)
   fastled --server (runs the compiler server in the current directory)
 
@@ -158,6 +161,18 @@ def parse_args() -> Args:
         help="Remove all FastLED containers and images",
     )
 
+    parser.add_argument(
+        "--playwright",
+        action="store_true",
+        help="Use Playwright browser instead of system default (requires 'pip install fastled[full]')",
+    )
+
+    parser.add_argument(
+        "--no-playwright-auto-resize",
+        action="store_true",
+        help="Disable automatic window resizing in Playwright browser",
+    )
+
     build_mode = parser.add_mutually_exclusive_group()
     build_mode.add_argument("--debug", action="store_true", help="Build in debug mode")
     build_mode.add_argument(

fastled/playwright_browser.py

@@ -0,0 +1,468 @@
+"""
+Playwright browser integration for FastLED WASM compiler.
+
+This module provides functionality to open the compiled FastLED sketch
+in a Playwright browser instead of the default system browser when
+the 'full' optional dependency is installed.
+"""
+
+import asyncio
+import sys
+import warnings
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from playwright.async_api import Browser, Page
+
+try:
+    from playwright.async_api import Browser, Page, async_playwright
+
+    PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    PLAYWRIGHT_AVAILABLE = False
+    async_playwright = None
+    Browser = Any  # type: ignore
+    Page = Any  # type: ignore
+
+
+def is_playwright_available() -> bool:
+    """Check if Playwright is available."""
+    return PLAYWRIGHT_AVAILABLE
+
+
+class PlaywrightBrowser:
+    """Playwright browser manager for FastLED sketches."""
+
+    def __init__(self, headless: bool = False, auto_resize: bool = True):
+        """Initialize the Playwright browser manager.
+
+        Args:
+            headless: Whether to run the browser in headless mode
+            auto_resize: Whether to automatically resize the browser window to fit content
+        """
+        if not PLAYWRIGHT_AVAILABLE:
+            raise ImportError(
+                "Playwright is not installed. Install with: pip install fastled[full]"
+            )
+
+        # debug
+        auto_resize = True
+
+        self.headless = headless
+        self.auto_resize = auto_resize
+        self.browser: Any = None
+        self.page: Any = None
+        self.playwright: Any = None
+
+    async def start(self) -> None:
+        """Start the Playwright browser."""
+        if self.playwright is None and async_playwright is not None:
+            self.playwright = await async_playwright().start()
+
+        if self.browser is None and self.playwright is not None:
+            # Try Chrome first, then Firefox, then WebKit
+            try:
+                self.browser = await self.playwright.chromium.launch(
+                    headless=self.headless,
+                    args=["--disable-web-security", "--allow-running-insecure-content"],
+                )
+            except Exception:
+                try:
+                    self.browser = await self.playwright.firefox.launch(
+                        headless=self.headless
+                    )
+                except Exception:
+                    self.browser = await self.playwright.webkit.launch(
+                        headless=self.headless
+                    )
+
+        if self.page is None and self.browser is not None:
+            # Create a new browser context and page
+            context = await self.browser.new_context()
+            self.page = await context.new_page()
+
+    async def open_url(self, url: str) -> None:
+        """Open a URL in the Playwright browser.
+
+        Args:
+            url: The URL to open
+        """
+        if self.page is None:
+            await self.start()
+
+        print(f"Opening FastLED sketch in Playwright browser: {url}")
+        if self.page is not None:
+            await self.page.goto(url)
+
+            # Wait for the page to load
+            await self.page.wait_for_load_state("networkidle")
+
+            # Set up auto-resizing functionality if enabled
+            if self.auto_resize:
+                await self._setup_auto_resize()
+
+    async def _setup_auto_resize(self) -> None:
+        """Set up automatic window resizing based on content size."""
+        if self.page is None:
+            print("[PYTHON] Cannot setup auto-resize: page is None")
+            return
+
+        print(
+            "[PYTHON] Setting up browser window tracking with viewport-only adjustment"
+        )
+
+        # Start polling loop that tracks browser window changes and adjusts viewport only
+        asyncio.create_task(self._track_browser_adjust_viewport())
+
+    async def _get_window_info(self) -> dict[str, int] | None:
+        """Get browser window dimensions information.
+
+        Returns:
+            Dictionary containing window dimensions or None if unable to retrieve
+        """
+        if self.page is None:
+            return None
+
+        try:
+            return await self.page.evaluate(
+                """
+                () => {
+                    return {
+                        outerWidth: window.outerWidth,
+                        outerHeight: window.outerHeight,
+                        innerWidth: window.innerWidth,
+                        innerHeight: window.innerHeight,
+                        contentWidth: document.documentElement.clientWidth,
+                        contentHeight: document.documentElement.clientHeight
+                    };
+                }
+                """
+            )
+        except Exception:
+            return None
+
+    async def _track_browser_adjust_viewport(self) -> None:
+        """Track browser window outer size changes and adjust viewport accordingly."""
+        if self.page is None:
+            return
+
+        print(
+            "[PYTHON] Starting browser window tracking (outer size → viewport adjustment)"
+        )
+        last_outer_size = None
+
+        while True:
+            try:
+                # Wait 1 second between polls
+                await asyncio.sleep(1)
+
+                # Check if page is still alive
+                if self.page is None or self.page.is_closed():
+                    print("[PYTHON] Page closed, stopping browser tracking")
+                    break
+
+                # Get browser window dimensions
+                window_info = await self._get_window_info()
+
+                if window_info:
+                    current_outer = (
+                        window_info["outerWidth"],
+                        window_info["outerHeight"],
+                    )
+
+                    # Print current state occasionally
+                    if last_outer_size is None or current_outer != last_outer_size:
+                        print(
+                            f"[PYTHON] Browser: outer={window_info['outerWidth']}x{window_info['outerHeight']}, content={window_info['contentWidth']}x{window_info['contentHeight']}"
+                        )
+
+                    # Track changes in OUTER window size (user resizes browser)
+                    if last_outer_size is None or current_outer != last_outer_size:
+
+                        if last_outer_size is not None:
+                            print("[PYTHON] *** BROWSER WINDOW RESIZED ***")
+                            print(
+                                f"[PYTHON] Outer window changed from {last_outer_size[0]}x{last_outer_size[1]} to {current_outer[0]}x{current_outer[1]}"
+                            )
+
+                        last_outer_size = current_outer
+
+                        # Set viewport to match the outer window size
+                        if not self.headless:
+                            try:
+                                outer_width = int(window_info["outerWidth"])
+                                outer_height = int(window_info["outerHeight"])
+
+                                print(
+                                    f"[PYTHON] Setting viewport to match outer window size: {outer_width}x{outer_height}"
+                                )
+
+                                await self.page.set_viewport_size(
+                                    {"width": outer_width, "height": outer_height}
+                                )
+                                print("[PYTHON] Viewport set successfully")
+
+                                # Wait briefly for browser to settle after viewport change
+                                # await asyncio.sleep(0.5)
+
+                                # Query the actual window dimensions after the viewport change
+                                updated_window_info = await self._get_window_info()
+
+                                if updated_window_info:
+
+                                    # Update our tracking with the actual final outer size
+                                    last_outer_size = (
+                                        updated_window_info["outerWidth"],
+                                        updated_window_info["outerHeight"],
+                                    )
+                                    print(
+                                        f"[PYTHON] Updated last_outer_size to actual final size: {last_outer_size}"
+                                    )
+                                else:
+                                    print("[PYTHON] Could not get updated window info")
+
+                            except Exception as e:
+                                print(f"[PYTHON] Failed to set viewport: {e}")
+
+                else:
+                    print("[PYTHON] Could not get browser window info")
+
+            except Exception as e:
+                print(f"[PYTHON] Error in browser tracking: {e}")
+                continue
+
+    async def wait_for_close(self) -> None:
+        """Wait for the browser to be closed."""
+        if self.browser is None:
+            return
+
+        try:
+            # Wait for the browser to be closed
+            while not self.browser.is_closed():
+                await asyncio.sleep(1)
+        except Exception:
+            pass
+
+    async def close(self) -> None:
+        """Close the Playwright browser."""
+        if self.page:
+            await self.page.close()
+            self.page = None
+
+        if self.browser:
+            await self.browser.close()
+            self.browser = None
+
+        if self.playwright:
+            await self.playwright.stop()
+            self.playwright = None
+
+
+def run_playwright_browser(
+    url: str, headless: bool = False, auto_resize: bool = True
+) -> None:
+    """Run Playwright browser in a separate process.
+
+    Args:
+        url: The URL to open
+        headless: Whether to run in headless mode
+        auto_resize: Whether to automatically resize the browser window to fit content
+    """
+    if not PLAYWRIGHT_AVAILABLE:
+        warnings.warn(
+            "Playwright is not installed. Install with: pip install fastled[full]. "
+            "Falling back to default browser."
+        )
+        return
+
+    async def main():
+        browser = PlaywrightBrowser(headless=headless, auto_resize=auto_resize)
+        try:
+            await browser.start()
+            await browser.open_url(url)
+
+            if not headless:
+                print("Playwright browser opened. Press Ctrl+C to close.")
+                await browser.wait_for_close()
+            else:
+                # In headless mode, just wait a bit for the page to load
+                await asyncio.sleep(2)
+
+        except KeyboardInterrupt:
+            print("\nClosing Playwright browser...")
+        finally:
+            await browser.close()
+
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nPlaywright browser closed.")
+    except Exception as e:
+        warnings.warn(
+            f"Playwright browser failed: {e}. Falling back to default browser."
+        )
+
+
+class PlaywrightBrowserProxy:
+    """Proxy object to manage Playwright browser lifecycle."""
+
+    def __init__(self):
+        self.process = None
+        self.browser_manager = None
+
+    def open(self, url: str, headless: bool = False, auto_resize: bool = True) -> None:
+        """Open URL with Playwright browser and keep it alive.
+
+        Args:
+            url: The URL to open
+            headless: Whether to run in headless mode
+            auto_resize: Whether to automatically resize the browser window to fit content
+        """
+        if not PLAYWRIGHT_AVAILABLE:
+            warnings.warn(
+                "Playwright is not installed. Install with: pip install fastled[full]. "
+                "Falling back to default browser."
+            )
+            # Fall back to default browser
+            import webbrowser
+
+            webbrowser.open(url)
+            return
+
+        try:
+            # Run Playwright in a separate process to avoid blocking
+            import multiprocessing
+
+            self.process = multiprocessing.Process(
+                target=run_playwright_browser_persistent,
+                args=(url, headless, auto_resize),
+            )
+            self.process.start()
+
+            # Register cleanup
+            import atexit
+
+            atexit.register(self.close)
+
+        except Exception as e:
+            warnings.warn(
+                f"Failed to start Playwright browser: {e}. Falling back to default browser."
+            )
+            import webbrowser
+
+            webbrowser.open(url)
+
+    def close(self) -> None:
+        """Close the Playwright browser."""
+        if self.process and self.process.is_alive():
+            print("Closing Playwright browser...")
+            self.process.terminate()
+            self.process.join(timeout=5)
+            if self.process.is_alive():
+                self.process.kill()
+            self.process = None
+
+
+def run_playwright_browser_persistent(
+    url: str, headless: bool = False, auto_resize: bool = True
+) -> None:
+    """Run Playwright browser in a persistent mode that stays alive until terminated.
+
+    Args:
+        url: The URL to open
+        headless: Whether to run in headless mode
+        auto_resize: Whether to automatically resize the browser window to fit content
+    """
+    if not PLAYWRIGHT_AVAILABLE:
+        return
+
+    async def main():
+        browser = PlaywrightBrowser(headless=headless, auto_resize=auto_resize)
+        try:
+            await browser.start()
+            await browser.open_url(url)
+
+            print(
+                "Playwright browser opened. Browser will remain open until the FastLED process exits."
+            )
+
+            # Keep the browser alive indefinitely
+            while True:
+                await asyncio.sleep(1)
+
+        except KeyboardInterrupt:
+            print("\nClosing Playwright browser...")
+        except Exception as e:
+            print(f"Playwright browser error: {e}")
+        finally:
+            await browser.close()
+
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nPlaywright browser closed.")
+    except Exception as e:
+        print(f"Playwright browser failed: {e}")
+
+
+def open_with_playwright(
+    url: str, headless: bool = False, auto_resize: bool = True
+) -> PlaywrightBrowserProxy:
+    """Open URL with Playwright browser and return a proxy object for lifecycle management.
+
+    This function can be used as a drop-in replacement for webbrowser.open().
+
+    Args:
+        url: The URL to open
+        headless: Whether to run in headless mode
+        auto_resize: Whether to automatically resize the browser window to fit content
+
+    Returns:
+        PlaywrightBrowserProxy object for managing the browser lifecycle
+    """
+    proxy = PlaywrightBrowserProxy()
+    proxy.open(url, headless, auto_resize)
+    return proxy
+
+
+def install_playwright_browsers() -> bool:
+    """Install Playwright browsers if not already installed.
+
+    Returns:
+        True if installation was successful or browsers were already installed
+    """
+    if not PLAYWRIGHT_AVAILABLE:
+        return False
+
+    try:
+        from playwright.sync_api import sync_playwright
+
+        with sync_playwright() as p:
+            # Try to launch a browser to see if it's installed
+            try:
+                browser = p.chromium.launch(headless=True)
+                browser.close()
+                return True
+            except Exception:
+                pass
+
+        # If we get here, browsers need to be installed
+        print("Installing Playwright browsers...")
+        import subprocess
+
+        result = subprocess.run(
+            [sys.executable, "-m", "playwright", "install", "chromium"],
+            capture_output=True,
+            text=True,
+        )
+
+        if result.returncode == 0:
+            print("Playwright browsers installed successfully.")
+            return True
+        else:
+            print(f"Failed to install Playwright browsers: {result.stderr}")
+            return False
+
+    except Exception as e:
+        print(f"Error installing Playwright browsers: {e}")
+        return False

{fastled-1.3.38.dist-info → fastled-1.3.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastled
-Version: 1.3.38
+Version: 1.3.39
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -22,6 +22,8 @@ Requires-Dist: Flask>=3.0.0
 Requires-Dist: flask-cors>=4.0.0
 Requires-Dist: livereload
 Requires-Dist: disklru>=2.0.4
+Provides-Extra: full
+Requires-Dist: playwright>=1.40.0; extra == "full"
 Dynamic: home-page
 Dynamic: license-file
 Dynamic: maintainer
@@ -71,7 +73,33 @@ $ cd mysketchdirectory
 $ fastled
 ```
 
+## Playwright Browser Support
 
+For enhanced browser control and automation capabilities, you can install the full version with Playwright support:
+
+```bash
+$ pip install fastled[full]
+```
+
+This enables the `--playwright` flag which opens your compiled sketch in a Playwright-controlled browser instead of your system's default browser:
+
+```bash
+$ fastled my_sketch --playwright
+```
+
+The Playwright browser provides better automation capabilities and is especially useful for:
+- Automated testing of your LED sketches
+- Consistent cross-platform browser behavior
+- Advanced debugging and development workflows
+- Persistent browser sessions that stay open until the FastLED process exits
+
+**Key Benefits:**
+- The Playwright browser remains open throughout your development session
+- Automatic cleanup when the FastLED process exits
+- Better control over browser behavior and automation capabilities
+- Consistent behavior across different platforms
+
+If Playwright is not installed and you use the `--playwright` flag, the system will gracefully fall back to your default browser.
 
 # Install
 
@@ -81,14 +109,26 @@ This is a python app, so any python package manager will work. We also provide p
 
 `pip install fastled`
 
+### Pip with Playwright Support
+
+`pip install fastled[full]`
+
 ### UV
 
 `uv pip install fastled --system`
 
+### UV with Playwright Support
+
+`uv pip install "fastled[full]" --system`
+
 ### Pipx
 
 `pipx install fastled`
 
+### Pipx with Playwright Support
+
+`pipx install "fastled[full]"`
+
 ### Executables
 
   * Windows: https://github.com/zackees/fastled-wasm/releases/latest/download/fastled-windows-x64.zip

{fastled-1.3.38.dist-info → fastled-1.3.39.dist-info}/RECORD

@@ -1,12 +1,12 @@
 fastled/__init__.py,sha256=NBk5Ef65nIe0F_rvBrSGeoyouFOKFeQXqHrTCJQheeI,7201
 fastled/__main__.py,sha256=OcKv2ER1_iQAsZzLIUb3C8hRC9L2clNOhCrjpshrlf4,336
-fastled/__version__.py,sha256=9FmVYi6n9qXRl6U6l1Xr9-rsxJ3ncEYDzHGxGM-sA_E,373
+fastled/__version__.py,sha256=P02pxWlKUAylIYVEU3tL1Bf3RXb-VwgZjzO4VqZoHmc,373
 fastled/app.py,sha256=TFVn4qIRdt7dYbpDWudEHrhvD9pwyj9sIGXs4F26nhk,5880
-fastled/args.py,sha256=kucRGYpff_YKfmMpwWsJh6WIrvW_UPcNlZNFdw15z-Y,3475
+fastled/args.py,sha256=sugtV0liHa8EnsTeXMMyeH0fO5DgeIzCbDcM5Pbr4k0,4010
 fastled/cli.py,sha256=drgR2AOxVrj3QEz58iiKscYAumbbin2vIV-k91VCOAA,561
 fastled/cli_test.py,sha256=W-1nODZrip_JU6BEbYhxOa4ckxduOsiX8zIoRkTyxv4,550
 fastled/cli_test_interactive.py,sha256=BjNhveZOk5aCffHbcrxPQQjWmAuj4ClVKKcKX5eY6yM,542
-fastled/client_server.py,sha256=2H3HBstR0kSKfLrz0LFbBIHy2WYBKc5VzhPxavhdS6o,20393
+fastled/client_server.py,sha256=XH38jdEkkfizMrHYMDis5XEQqlG1XS7Bd-Yg1tQ1Zuk,20693
 fastled/compile_server.py,sha256=yQtwLOSKINO1CKD0NWxf-7YQKSatf9sF9RuqaWGOkCs,3038
 fastled/compile_server_impl.py,sha256=9vTGaDQ0W_g9Xsfy0gC3nJEc2g_pnXcF4VO2U3GLOVg,11982
 fastled/docker_manager.py,sha256=rkq39ZKrU6NHIyDa3mzs0Unb6o9oMeAwxhqiuHJU_RY,40291
@@ -14,9 +14,10 @@ fastled/filewatcher.py,sha256=gEcJJHTDJ1X3gKJzltmEBhixWGbZj2eJD7a4vwSvITQ,10036
 fastled/keyboard.py,sha256=UTAsqCn1UMYnB8YDzENiLTj4GeL45tYfEcO7_5fLFEg,3556
 fastled/keyz.py,sha256=LO-8m_7CpNDiZLM-FXhQ30f9gN1bUYz5lOsUPTIbI-c,4020
 fastled/live_client.py,sha256=yp_ujG92EHYpSedGOUteuG2nQvMKbp1GbUpgQ6nU4Dc,3083
-fastled/open_browser.py,sha256=DFyMrc1qic4Go7eLNPqMaLuMvTaE73NixdfSKV0yyp8,3709
-fastled/parse_args.py,sha256=Uu7aNaXtV9afE-z_zpINzykPnFewdN6Goiqgs6Rtt-c,11359
+fastled/open_browser.py,sha256=So4znH-jjc-dheyRVGXrKcLj2vKgfGxCl_ECEfILY9g,5392
+fastled/parse_args.py,sha256=hNyMeVlN2TX3MbhUkIAdVIeByHLoGFxuajXYmwK_7Fg,11948
 fastled/paths.py,sha256=VsPmgu0lNSCFOoEC0BsTYzDygXqy15AHUfN-tTuzDZA,99
+fastled/playwright_browser.py,sha256=4Awad4ZIxWW-n9DMYwSGJBEzd6_7PA0ThQNms1kDxh4,16106
 fastled/print_filter.py,sha256=nc_rqYYdCUPinFycaK7fiQF5PG1up51pmJptR__QyAs,1499
 fastled/project_init.py,sha256=bBt4DwmW5hZkm9ICt9Qk-0Nr_0JQM7icCgH5Iv-bCQs,3984
 fastled/select_sketch_directory.py,sha256=-eudwCns3AKj4HuHtSkZAFwbnf005SNL07pOzs9VxnE,1383
@@ -37,9 +38,9 @@ fastled/site/build.py,sha256=2YKU_UWKlJdGnjdbAbaL0co6kceFMSTVYwH1KCmgPZA,13987
 fastled/site/examples.py,sha256=s6vj2zJc6BfKlnbwXr1QWY1mzuDBMt6j5MEBOWjO_U8,155
 fastled/test/can_run_local_docker_tests.py,sha256=LEuUbHctRhNNFWcvnz2kEGmjDJeXO4c3kNpizm3yVJs,400
 fastled/test/examples.py,sha256=GfaHeY1E8izBl6ZqDVjz--RHLyVR4NRnQ5pBesCFJFY,1673
-fastled-1.3.38.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-fastled-1.3.38.dist-info/METADATA,sha256=j0Pj8VUdX6Tvsf6r5lbEfFF9dLO0FCJLHcm3Rw7feuo,30847
-fastled-1.3.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fastled-1.3.38.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
-fastled-1.3.38.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
-fastled-1.3.38.dist-info/RECORD,,
+fastled-1.3.39.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+fastled-1.3.39.dist-info/METADATA,sha256=p2oZYp8GXF-76q_IB9VE41428EnWMBjhXracpjGkdzg,32198
+fastled-1.3.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastled-1.3.39.dist-info/entry_points.txt,sha256=RCwmzCSOS4-C2i9EziANq7Z2Zb4KFnEMR1FQC0bBwAw,101
+fastled-1.3.39.dist-info/top_level.txt,sha256=Bbv5kpJpZhWNCvDF4K0VcvtBSDMa8B7PTOrZa9CezHY,8
+fastled-1.3.39.dist-info/RECORD,,