Add code

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

app.py

@@ -1,8 +1,205 @@
+import pickle
+import json
+import os
+
 import gradio as gr
+from gradio_dualvision import DualVisionApp
+from gradio_dualvision.gradio_patches.radio import Radio
+from PIL import Image
+import numpy as np
+
+from model import build_thera
+from super_resolve import process
+
+CHECKPOINT = "checkpoints/thera-edsr-plus.pkl"
+
+
+class TheraApp(DualVisionApp):
+    DEFAULT_SCALE = 3.1415
+    DEFAULT_DO_ENSEMBLE = False
+
+    def make_header(self):
+        gr.Markdown(
+            """
+            ## Thera: Aliasing-Free Arbitrary-Scale Super-Resolution with Neural Heat Fields
+            <p align="center">
+            <a title="Website" href="https://therasr.github.io/" target="_blank" rel="noopener noreferrer" style="display: inline-block;">
+                <img src="https://img.shields.io/badge/%E2%99%A5%20Project%20-Website-blue">
+            </a>
+            <a title="arXiv" href="https://arxiv.org/pdf/2311.17643" target="_blank" rel="noopener noreferrer" style="display: inline-block;">
+                <img src="https://img.shields.io/badge/%F0%9F%93%84%20Read%20-Paper-AF3436">
+            </a>
+            <a title="Github" href="https://github.com/prs-eth/thera" target="_blank" rel="noopener noreferrer" style="display: inline-block;">
+                <img src="https://img.shields.io/github/stars/prs-eth/thera?label=GitHub%20%E2%98%85&logo=github&color=C8C" alt="badge-github-stars">
+            </a>
+            </p>                    
+            <p align="center" style="margin-top: 0px;">
+                Upload a photo or select an example below to do arbitrary-scale super-resolution in real time!
+            </p>
+        """
+        )
+
+    def build_user_components(self):
+        with gr.Column():
+            scale = gr.Slider(
+                label="Scaling factor",
+                minimum=1,
+                maximum=6,
+                step=0.01,
+                value=self.DEFAULT_SCALE,
+            )
+            do_ensemble = gr.Radio(
+                [
+                    ("No", False),
+                    ("Yes", True),
+                ],
+                label="Do Ensemble",
+                value=self.DEFAULT_DO_ENSEMBLE,
+            )
+        return {
+            "scale": scale,
+            "do_ensemble": do_ensemble,
+        }
+
+    def process(self, image_in: Image.Image, **kwargs):
+        scale = kwargs.get("scale", self.DEFAULT_SCALE)
+        do_ensemble = kwargs.get("do_ensemble", self.DEFAULT_DO_ENSEMBLE)
+
+        source = np.asarray(image_in) / 255.
+
+        # determine target shape
+        target_shape = (
+            round(source.shape[0] * scale),
+            round(source.shape[1] * scale),
+        )
+
+        # load model
+        with open(CHECKPOINT, 'rb') as fh:
+            check = pickle.load(fh)
+            params, backbone, size = check['model'], check['backbone'], check['size']
+
+        model = build_thera(3, backbone, size)
+
+        out = process(source, model, params, target_shape, do_ensemble=do_ensemble)
+        out = Image.fromarray(np.asarray(out))
+
+        nearest = image_in.resize(out.size, Image.NEAREST)
+
+        out_modalities = {
+            "nearest": nearest,
+            "out": out,
+        }
+        out_settings = {
+            'scale': scale,
+            'do_ensemble': do_ensemble,
+        }
+        return out_modalities, out_settings
+
+    def process_components(
+        self, image_in, modality_selector_left, modality_selector_right, **kwargs
+    ):
+        if image_in is None:
+            raise gr.Error("Input image is required")
+
+        image_settings = {}
+        if isinstance(image_in, str):
+            image_settings_path = image_in + ".settings.json"
+            if os.path.isfile(image_settings_path):
+                with open(image_settings_path, "r") as f:
+                    image_settings = json.load(f)
+            image_in = Image.open(image_in).convert("RGB")
+        else:
+            if not isinstance(image_in, Image.Image):
+                raise gr.Error(f"Input must be a PIL image, got {type(image_in)}")
+            image_in = image_in.convert("RGB")
+        image_settings.update(kwargs)
+
+        results_dict, results_settings = self.process(image_in, **image_settings)
+
+        if not isinstance(results_dict, dict):
+            raise gr.Error(
+                f"`process` must return a dict[str, PIL.Image]. Got type: {type(results_dict)}"
+            )
+        if len(results_dict) == 0:
+            raise gr.Error("`process` did not return any modalities")
+        for k, v in results_dict.items():
+            if not isinstance(k, str):
+                raise gr.Error(
+                    f"Output dict must have string keys. Found key of type {type(k)}: {repr(k)}"
+                )
+            if k == self.key_original_image:
+                raise gr.Error(
+                    f"Output dict must not have an '{self.key_original_image}' key; it is reserved for the input"
+                )
+            if not isinstance(v, Image.Image):
+                raise gr.Error(
+                    f"Value for key '{k}' must be a PIL Image, got type {type(v)}"
+                )
+        if len(results_settings) != len(self.input_keys):
+            raise gr.Error(
+                f"Expected number of settings ({len(self.input_keys)}), returned ({len(results_settings)})"
+            )
+        if any(k not in results_settings for k in self.input_keys):
+            raise gr.Error(f"Mismatching setgings keys")
+        results_settings = {
+            k: cls(**ctor_args, value=results_settings[k])
+            for k, cls, ctor_args in zip(
+                self.input_keys, self.input_cls, self.input_kwargs
+            )
+        }
+
+        results_dict = {
+            **results_dict,
+            self.key_original_image: image_in,
+        }
+
+        results_state = [[v, k] for k, v in results_dict.items()]
+        modalities = list(results_dict.keys())
+
+        modality_left = (
+            modality_selector_left
+            if modality_selector_left in modalities
+            else modalities[0]
+        )
+        modality_right = (
+            modality_selector_right
+            if modality_selector_right in modalities
+            else modalities[1]
+        )
 
-def greet(name):
-    return "Hello " + name + "!!"
+        return [
+            results_state,  # goes to a gr.Gallery
+            [
+                results_dict[modality_left],
+                results_dict[modality_right],
+            ],  # ImageSliderPlus
+            Radio(
+                choices=modalities,
+                value=modality_left,
+                label="Left",
+                key="Left",
+            ),
+            Radio(
+                choices=modalities if self.left_selector_visible else modalities[1:],
+                value=modality_right,
+                label="Right",
+                key="Right",
+            ),
+            *results_settings.values(),
+        ]
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
 
+with TheraApp(
+        title="Thera Arbitrary-Scale Super-Resolution",
+        examples_path="files",
+        examples_per_page=12,
+        squeeze_canvas=True,
+        advanced_settings_can_be_half_width=False,
+        #spaces_zero_gpu_enabled=True,
+) as demo:
+    demo.queue(
+        api_open=False,
+    ).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+    )

checkpoints/thera-edsr-plus.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a805ca6f0486d9eba8f228200340a0e6aedde16529e11fc7b98dc26d830d9aa8
+size 31632862

gradio_dualvision/__init__.py

@@ -0,0 +1,26 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+
+from .version import __version__
+from .app_template import DualVisionApp

gradio_dualvision/app_template.py

@@ -0,0 +1,614 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import glob
+import json
+import os
+import re
+
+import gradio as gr
+import spaces
+from PIL import Image
+from gradio.components.base import Component
+
+from .gradio_patches.examples import Examples
+from .gradio_patches.gallery import Gallery
+from .gradio_patches.imagesliderplus import ImageSliderPlus
+from .gradio_patches.radio import Radio
+
+
+class DualVisionApp(gr.Blocks):
+    def __init__(
+        self,
+        title,
+        examples_path="examples",
+        examples_per_page=12,
+        examples_cache="lazy",
+        squeeze_canvas=True,
+        squeeze_viewport_height_pct=75,
+        left_selector_visible=False,
+        advanced_settings_can_be_half_width=True,
+        key_original_image="Original",
+        spaces_zero_gpu_enabled=False,
+        spaces_zero_gpu_duration=None,
+        slider_position=0.5,
+        slider_line_color="#FFF",
+        slider_line_width="4px",
+        slider_arrows_color="#FFF",
+        slider_arrows_width="2px",
+        gallery_thumb_min_size="96px",
+        **kwargs,
+    ):
+        """
+        A wrapper around Gradio Blocks class that implements an image processing demo template. All the user has to do
+        is to subclass this class and implement two methods: `process` implementing the image processing, and
+        `build_user_components` implementing Gradio components reading the additional processing arguments.
+        Args:
+            title: Title of the application (str, required).
+            examples_path: Base path where examples will be searched (Default: `"examples"`).
+            examples_per_page: How many examples to show at the bottom of the app (Default: `12`).
+            examples_cache: Examples caching policy, corresponding to `cache_examples` argument of gradio.Examples (Default: `"lazy"`).
+            squeeze_canvas: When True, the image is fit to the browser viewport. When False, the image is fit to width (Default: `True`).
+            squeeze_viewport_height_pct: Percentage of the browser viewport height (Default: `75`).
+            left_selector_visible: Whether controls for changing modalities in the left part of the slider are visible (Default: `False`).
+            key_original_image: Name of the key under which the input image is shown in the modality selectors (Default: `"Original"`).
+            advanced_settings_can_be_half_width: Whether allow placing advanced settings dropdown in half-column space whenever possible (Default: `True`).
+            spaces_zero_gpu_enabled: When True, the app wraps the processing function with the ZeroGPU decorator.
+            spaces_zero_gpu_duration: Defines an integer duration in seconds passed into the ZeroGPU decorator.
+            slider_position: Position of the slider between 0 and 1 (Default: `0.5`).
+            slider_line_color: Color of the slider line (Default: `"#FFF"`).
+            slider_line_width: Width of the slider line (Default: `"4px"`).
+            slider_arrows_color: Color of the slider arrows (Default: `"#FFF"`).
+            slider_arrows_width: Width of the slider arrows (Default: `2px`).
+            gallery_thumb_min_size: Min size of the gallery thumbnail (Default: `96px`).
+            **kwargs: Any other arguments that Gradio Blocks class can take.
+        """
+        squeeze_viewport_height_pct = int(squeeze_viewport_height_pct)
+        if not 50 <= squeeze_viewport_height_pct <= 100:
+            raise gr.Error(
+                "`squeeze_viewport_height_pct` should be an integer between 50 and 100."
+            )
+        if not os.path.isdir(examples_path):
+            raise gr.Error("`examples_path` should be a directory.")
+        if not 0 <= slider_position <= 1:
+            raise gr.Error("`slider_position` should be between 0 and 1.")
+        kwargs = {k: v for k, v in kwargs.items()}
+        kwargs["title"] = title
+        self.examples_path = examples_path
+        self.examples_per_page = examples_per_page
+        self.examples_cache = examples_cache
+        self.key_original_image = key_original_image
+        self.slider_position = slider_position
+        self.input_keys = None
+        self.input_cls = None
+        self.input_kwargs = None
+        self.left_selector_visible = left_selector_visible
+        self.advanced_settings_can_be_half_width = advanced_settings_can_be_half_width
+        if spaces_zero_gpu_enabled:
+            self.process_components = spaces.GPU(
+                self.process_components, duration=spaces_zero_gpu_duration
+            )
+        self.head = ""
+        self.head += """
+            <script>
+                let observerFooterButtons = new MutationObserver((mutationsList, observer) => {
+                    const oldButtonLeft = document.querySelector(".show-api");
+                    const oldButtonRight = document.querySelector(".built-with");
+                    if (!oldButtonRight || !oldButtonLeft) {
+                        return;
+                    }
+                    observer.disconnect();
+
+                    const parentDiv = oldButtonLeft.parentNode;
+                    if (!parentDiv) return;
+
+                    const createButton = (referenceButton, text, href) => {
+                        let newButton = referenceButton.cloneNode(true);
+                        newButton.href = href;
+                        newButton.textContent = text;
+                        newButton.className = referenceButton.className;
+                        newButton.style.textDecoration = "none";
+                        newButton.style.display = "inline-block";
+                        newButton.style.cursor = "pointer";
+                        return newButton;
+                    };
+
+                    const newButton0 = createButton(oldButtonRight, "Built with Gradio DualVision", "https://github.com/toshas/gradio-dualvision");
+                    const newButton1 = createButton(oldButtonRight, "Template by Anton Obukhov", "https://www.obukhov.ai");
+                    const newButton2 = createButton(oldButtonRight, "Licensed under CC BY-SA 4.0", "http://creativecommons.org/licenses/by-sa/4.0/");
+
+                    const separatorDiv = document.createElement("div");
+                    separatorDiv.className = "svelte-1rjryqp";
+                    separatorDiv.textContent = "·";
+
+                    parentDiv.replaceChild(newButton0, oldButtonLeft);
+                    parentDiv.replaceChild(newButton1, oldButtonRight);
+                    parentDiv.appendChild(separatorDiv);
+                    parentDiv.appendChild(newButton2);
+                });
+                observerFooterButtons.observe(document.body, { childList: true, subtree: true });
+            </script>
+        """
+        if kwargs.get("analytics_enabled") is not False:
+            self.head += f"""
+                <script async src="https://www.googletagmanager.com/gtag/js?id=G-1FWSVCGZTG"></script>
+                <script>
+                    window.dataLayer = window.dataLayer || [];
+                    function gtag() {{dataLayer.push(arguments);}}
+                    gtag('js', new Date());
+                    gtag('config', 'G-1FWSVCGZTG');
+                </script>
+            """
+        self.css = f"""
+            body {{                      /* tighten the layout */
+                flex-grow: 0 !important;
+            }}
+            .sliderrow {{                /* center the slider */
+                display: flex;
+                justify-content: center;
+            }}
+            .slider {{                   /* center the slider */
+                display: flex;
+                justify-content: center;
+                width: 100%;
+            }}
+            .slider .disabled {{         /* hide the main slider before image load */
+                visibility: hidden;
+            }}
+            .slider .svelte-9gxdi0 {{    /* hide the component label in the top-left corner before image load */
+                visibility: hidden;
+            }}
+            .slider .svelte-kzcjhc .icon-wrap {{
+                height: 0px;             /* remove unnecessary spaces in captions before image load */
+            }}
+            .slider .svelte-kzcjhc.wrap {{
+                padding-top: 0px;        /* remove unnecessary spaces in captions before image load */
+            }}
+            .slider .svelte-3w3rth {{    /* hide the dummy icon from the right pane before image load */
+                visibility: hidden;
+            }}
+            .svelte-106mu0e.icon-buttons {{ /* download button */
+                /*right: unset;*/
+                /*left: 8px;*/
+            }}
+            .slider .fixed {{            /* fix the opacity of the right pane image */
+                background-color: var(--anim-block-background-fill);
+            }}
+            .slider .inner {{            /* style slider line */
+                width: {slider_line_width};
+                background: {slider_line_color};
+            }}
+            .slider .icon-wrap svg {{    /* style slider arrows */
+                stroke: {slider_arrows_color};
+                stroke-width: {slider_arrows_width};
+            }}
+            .slider .icon-wrap path {{    /* style slider arrows */
+                fill: {slider_arrows_color};
+            }}
+            .row_reverse {{
+                flex-direction: row-reverse;
+            }}
+            .gallery.svelte-l4wpk0 {{        /* make examples gallery tiles square */
+                width: max({gallery_thumb_min_size}, calc(100vw / 8));
+                height: max({gallery_thumb_min_size}, calc(100vw / 8));
+            }}
+            .gallery.svelte-l4wpk0 img {{    /* make examples gallery tiles square */
+                width: max({gallery_thumb_min_size}, calc(100vw / 8));
+                height: max({gallery_thumb_min_size}, calc(100vw / 8));
+            }}
+            .gallery.svelte-l4wpk0 img {{    /* remove slider line from previews */
+                clip-path: inset(0 0 0 0);
+            }}
+            .gallery.svelte-l4wpk0 span {{   /* remove slider line from previews */
+                visibility: hidden;
+            }}
+            h1, h2, h3 {{                    /* center markdown headings */
+                text-align: center;
+                display: block;
+            }}
+            #settings-accordion {{
+                margin: 0 auto;
+                max-width: 500px;
+            }}
+        """
+        if squeeze_canvas:
+            self.head += f"""
+                <script>
+                    // fixes vertical size of the component when used inside of iframeResizer (on spaces)
+                    function squeezeViewport() {{
+                        if (typeof window.parentIFrame === "undefined") return;
+                        const images = document.querySelectorAll('.slider img');
+                        window.parentIFrame.getPageInfo((info) => {{
+                            images.forEach((img) => {{
+                                const imgMaxHeightNew = (info.clientHeight * {squeeze_viewport_height_pct}) / 100;
+                                img.style.maxHeight = `${{imgMaxHeightNew}}px`;
+                                // window.parentIFrame.size(0, null);  // tighten the layout; body's flex-grow: 0 is less intrusive
+                            }});
+                        }});
+                    }}
+                    window.addEventListener('resize', squeezeViewport);
+
+                    // fixes gradio-imageslider wrong position behavior when using fitting to content by triggering resize
+                    let observer = new MutationObserver((mutationsList) => {{
+                        const images = document.querySelectorAll('.slider img');
+                        images.forEach((img) => {{
+                            if (img.complete) {{
+                                window.dispatchEvent(new Event('resize'));
+                            }} else {{
+                                img.onload = () => {{
+                                    window.dispatchEvent(new Event('resize'));
+                                }}
+                            }}
+                        }});
+                    }});
+                    observer.observe(document.body, {{ childList: true, subtree: true }});
+                </script>
+            """
+            self.css += f"""
+                .slider {{               /* make the slider dimensions fit to the uploaded content dimensions */
+                    max-width: fit-content;
+                }}
+                .slider .half-wrap {{    /* make the empty component width almost full before image load */
+                    width: 70vw;
+                }}
+                .slider img {{           /* Ensures image fits inside the viewport */
+                    max-height: {squeeze_viewport_height_pct}vh;
+                }}
+            """
+        else:
+            self.css += f"""
+                .slider .half-wrap {{    /* make the upload area full width */
+                    width: 100%;
+                }}
+            """
+        kwargs["css"] = kwargs.get("css", "") + self.css
+        kwargs["head"] = kwargs.get("head", "") + self.head
+        super().__init__(**kwargs)
+        with self:
+            self.make_interface()
+
+    def process(self, image_in: Image.Image, **kwargs):
+        """
+        Process an input image into multiple modalities using the provided arguments or default settings.
+        Returns two dictionaries: one containing the modalities and another with the actual settings.
+        Override this method in a subclass.
+        """
+        raise NotImplementedError("Please override the `process` method.")
+
+    def build_user_components(self):
+        """
+        Create gradio components for the Advanced Settings dropdown, that will be passed into the `process` method.
+        Use gr.Row(), gr.Column(), and other context managers to arrange the components. Return them as a flat dict.
+        Override this method in a subclass.
+        """
+        raise NotImplementedError("Please override the `build_user_components` method.")
+
+    def discover_examples(self):
+        """
+        Looks for valid image filenames.
+        """
+        pattern = re.compile(r".*\.(jpg|JPG|jpeg|JPEG|png|PNG)$")
+        paths = glob.glob(f"{self.examples_path}/*")
+        out = list(sorted(filter(pattern.match, paths)))
+        return out
+
+    def process_components(
+        self, image_in, modality_selector_left, modality_selector_right, **kwargs
+    ):
+        """
+        Wraps the call to `process`. Returns results in a structure used by the gallery, slider, radio components.
+        """
+        if image_in is None:
+            raise gr.Error("Input image is required")
+
+        image_settings = {}
+        if isinstance(image_in, str):
+            image_settings_path = image_in + ".settings.json"
+            if os.path.isfile(image_settings_path):
+                with open(image_settings_path, "r") as f:
+                    image_settings = json.load(f)
+            image_in = Image.open(image_in).convert("RGB")
+        else:
+            if not isinstance(image_in, Image.Image):
+                raise gr.Error(f"Input must be a PIL image, got {type(image_in)}")
+            image_in = image_in.convert("RGB")
+        image_settings.update(kwargs)
+
+        results_dict, results_settings = self.process(image_in, **image_settings)
+
+        if not isinstance(results_dict, dict):
+            raise gr.Error(
+                f"`process` must return a dict[str, PIL.Image]. Got type: {type(results_dict)}"
+            )
+        if len(results_dict) == 0:
+            raise gr.Error("`process` did not return any modalities")
+        for k, v in results_dict.items():
+            if not isinstance(k, str):
+                raise gr.Error(
+                    f"Output dict must have string keys. Found key of type {type(k)}: {repr(k)}"
+                )
+            if k == self.key_original_image:
+                raise gr.Error(
+                    f"Output dict must not have an '{self.key_original_image}' key; it is reserved for the input"
+                )
+            if not isinstance(v, Image.Image):
+                raise gr.Error(
+                    f"Value for key '{k}' must be a PIL Image, got type {type(v)}"
+                )
+        if len(results_settings) != len(self.input_keys):
+            raise gr.Error(
+                f"Expected number of settings ({len(self.input_keys)}), returned ({len(results_settings)})"
+            )
+        if any(k not in results_settings for k in self.input_keys):
+            raise gr.Error(f"Mismatching setgings keys")
+        results_settings = {
+            k: cls(**ctor_args, value=results_settings[k])
+            for k, cls, ctor_args in zip(
+                self.input_keys, self.input_cls, self.input_kwargs
+            )
+        }
+
+        results_dict = {
+            self.key_original_image: image_in,
+            **results_dict,
+        }
+
+        results_state = [[v, k] for k, v in results_dict.items()]
+        modalities = list(results_dict.keys())
+
+        modality_left = (
+            modality_selector_left
+            if modality_selector_left in modalities
+            else modalities[0]
+        )
+        modality_right = (
+            modality_selector_right
+            if modality_selector_right in modalities
+            else modalities[1]
+        )
+
+        return [
+            results_state,  # goes to a gr.Gallery
+            [
+                results_dict[modality_left],
+                results_dict[modality_right],
+            ],  # ImageSliderPlus
+            Radio(
+                choices=modalities,
+                value=modality_left,
+                label="Left",
+                key="Left",
+            ),
+            Radio(
+                choices=modalities if self.left_selector_visible else modalities[1:],
+                value=modality_right,
+                label="Right",
+                key="Right",
+            ),
+            *results_settings.values(),
+        ]
+
+    def on_process_first(
+        self,
+        image_slider,
+        modality_selector_left=None,
+        modality_selector_right=None,
+        *args,
+    ):
+        image_in = image_slider[0]
+        input_dict = {}
+        if len(args) > 0:
+            input_dict = {k: v for k, v in zip(self.input_keys, args)}
+        return self.process_components(
+            image_in, modality_selector_left, modality_selector_right, **input_dict
+        )
+
+    def on_process_subsequent(
+        self, results_state, modality_selector_left, modality_selector_right, *args
+    ):
+        if results_state is None:
+            raise gr.Error("Upload an image first or use an example below.")
+        results_state = {k: v for v, k in results_state}
+        image_in = results_state[self.key_original_image]
+        input_dict = {k: v for k, v in zip(self.input_keys, args)}
+        return self.process_components(
+            image_in, modality_selector_left, modality_selector_right, **input_dict
+        )
+
+    def on_selector_change_left(
+        self, results_state, image_slider, modality_selector_left
+    ):
+        results_state = {k: v for v, k in results_state}
+        return [results_state[modality_selector_left], image_slider[1]]
+
+    def on_selector_change_right(
+        self, results_state, image_slider, modality_selector_right
+    ):
+        results_state = {k: v for v, k in results_state}
+        return [image_slider[0], results_state[modality_selector_right]]
+
+    def make_interface(self):
+        """
+        Constructs the entire Gradio Blocks interface.
+        """
+        self.make_header()
+
+        results_state = Gallery(visible=False)
+
+        image_slider = self.make_slider()
+
+        with gr.Row():
+            modality_selector_left, modality_selector_right = (
+                self.make_modality_selectors(reverse_visual_order=False)
+            )
+        user_components, btn_clear, btn_submit = self.make_advanced_settings()
+
+        self.make_examples(
+            image_slider,
+            [
+                results_state,
+                image_slider,
+                modality_selector_left,
+                modality_selector_right,
+                *user_components.values(),
+            ],
+        )
+
+        image_slider.upload(
+            fn=self.on_process_first,
+            inputs=[
+                image_slider,
+                modality_selector_left,
+                modality_selector_right,
+                *user_components.values(),
+            ],
+            outputs=[
+                results_state,
+                image_slider,
+                modality_selector_left,
+                modality_selector_right,
+                *user_components.values(),
+            ],
+        )
+
+        btn_submit.click(
+            fn=self.on_process_subsequent,
+            inputs=[
+                results_state,
+                modality_selector_left,
+                modality_selector_right,
+                *user_components.values(),
+            ],
+            outputs=[
+                results_state,
+                image_slider,
+                modality_selector_left,
+                modality_selector_right,
+                *user_components.values(),
+            ],
+        )
+
+        btn_clear.click(
+            fn=lambda: (None, None),
+            inputs=[],
+            outputs=[image_slider, results_state],
+        )
+
+        modality_selector_left.input(
+            fn=self.on_selector_change_left,
+            inputs=[results_state, image_slider, modality_selector_left],
+            outputs=image_slider,
+        )
+        modality_selector_right.input(
+            fn=self.on_selector_change_right,
+            inputs=[results_state, image_slider, modality_selector_right],
+            outputs=image_slider,
+        )
+
+    def make_header(self):
+        """
+        Create a header section with Markdown and HTML.
+        Default: just the project title.
+        """
+        gr.Markdown(f"# {self.title}")
+
+    def make_slider(self):
+        with gr.Row(elem_classes="sliderrow"):
+            return ImageSliderPlus(
+                label=self.title,
+                type="filepath",
+                elem_classes="slider",
+                position=self.slider_position,
+            )
+
+    def make_modality_selectors(self, reverse_visual_order=False):
+        modality_selector_left = Radio(
+            choices=None,
+            value=None,
+            label="Left",
+            key="Left",
+            show_label=False,
+            container=False,
+            visible=self.left_selector_visible,
+            render=not reverse_visual_order,
+        )
+        modality_selector_right = Radio(
+            choices=None,
+            value=None,
+            label="Right",
+            key="Right",
+            show_label=False,
+            container=False,
+            elem_id="selector_right",
+            visible=False,
+            render=not reverse_visual_order,
+        )
+        if reverse_visual_order:
+            modality_selector_right.render()
+            modality_selector_left.render()
+        return modality_selector_left, modality_selector_right
+
+    def make_examples(self, inputs, outputs):
+        examples = self.discover_examples()
+        if not isinstance(examples, list):
+            raise gr.Error("`discover_examples` must return a list of paths")
+        if any(not os.path.isfile(path) for path in examples):
+            raise gr.Error("Not all example paths are valid files")
+        examples_dirname = os.path.basename(os.path.normpath(self.examples_path))
+        return Examples(
+            examples=[
+                (e, e) for e in examples
+            ],  # tuples like this seem to work better with the gallery
+            inputs=inputs,
+            outputs=outputs,
+            examples_per_page=self.examples_per_page,
+            cache_examples=self.examples_cache,
+            fn=self.on_process_first,
+            directory_name=examples_dirname,
+        )
+
+    def make_advanced_settings(self):
+        with gr.Accordion("Advanced Settings", open=False, elem_id="settings-accordion"):
+            user_components = self.build_user_components()
+            if not isinstance(user_components, dict) or any(
+                not isinstance(k, str) or not isinstance(v, Component)
+                for k, v in user_components.items()
+            ):
+                raise gr.Error(
+                    "`build_user_components` must return a dict of Gradio components with string keys. A dict of the "
+                    "same structure will be passed into the `process` function."
+                )
+            with gr.Row():
+                btn_clear, btn_submit = self.make_buttons()
+        self.input_keys = list(user_components.keys())
+        self.input_cls = list(v.__class__ for v in user_components.values())
+        self.input_kwargs = [
+            {k: v for k, v in c.constructor_args.items() if k not in ("value")}
+            for c in user_components.values()
+        ]
+        return user_components, btn_clear, btn_submit
+
+    def make_buttons(self):
+        btn_clear = gr.Button("Clear")
+        btn_submit = gr.Button("Apply", variant="primary")
+        return btn_clear, btn_submit

gradio_dualvision/gradio_patches/examples.py

@@ -0,0 +1,36 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+from pathlib import Path
+import gradio
+from gradio.utils import get_cache_folder
+
+
+class Examples(gradio.helpers.Examples):
+    def __init__(self, *args, directory_name=None, **kwargs):
+        super().__init__(*args, **kwargs, _initiated_directly=False)
+        if directory_name is not None:
+            self.cached_folder = get_cache_folder() / directory_name
+            self.cached_file = Path(self.cached_folder) / "log.csv"
+            self.cached_indices_file = Path(self.cached_folder) / "indices.csv"
+        self.create()

gradio_dualvision/gradio_patches/gallery.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from gradio.components.gallery import (
+    GalleryImageType,
+    CaptionedGalleryImageType,
+    GalleryImage,
+    GalleryData,
+)
+from pathlib import Path
+from urllib.parse import urlparse
+
+import gradio
+import numpy as np
+import PIL.Image
+from gradio_client.utils import is_http_url_like
+
+from gradio import processing_utils, utils, wasm_utils
+from gradio.data_classes import FileData
+
+
+class Gallery(gradio.Gallery):
+    def postprocess(
+        self,
+        value: list[GalleryImageType | CaptionedGalleryImageType] | None,
+    ) -> GalleryData:
+        """
+        This is a patched version of the original function, wherein the format for PIL is computed based on the data type:
+        format = "png" if img.mode == "I;16" else "webp"
+        """
+        if value is None:
+            return GalleryData(root=[])
+        output = []
+
+        def _save(img):
+            url = None
+            caption = None
+            orig_name = None
+            if isinstance(img, (tuple, list)):
+                img, caption = img
+            if isinstance(img, np.ndarray):
+                file = processing_utils.save_img_array_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=self.format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, PIL.Image.Image):
+                format = "png" #if img.mode == "I;16" else "webp"
+                file = processing_utils.save_pil_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, str):
+                file_path = img
+                if is_http_url_like(img):
+                    url = img
+                    orig_name = Path(urlparse(img).path).name
+                else:
+                    url = None
+                    orig_name = Path(img).name
+            elif isinstance(img, Path):
+                file_path = str(img)
+                orig_name = img.name
+            else:
+                raise ValueError(f"Cannot process type as image: {type(img)}")
+            return GalleryImage(
+                image=FileData(path=file_path, url=url, orig_name=orig_name),
+                caption=caption,
+            )
+
+        if wasm_utils.IS_WASM:
+            for img in value:
+                output.append(_save(img))
+        else:
+            with ThreadPoolExecutor() as executor:
+                for o in executor.map(_save, value):
+                    output.append(o)
+        return GalleryData(root=output)

gradio_dualvision/gradio_patches/gallery.pyi

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor
+from gradio.components.gallery import (
+    GalleryImageType,
+    CaptionedGalleryImageType,
+    GalleryImage,
+    GalleryData,
+)
+from pathlib import Path
+from urllib.parse import urlparse
+
+import gradio
+import numpy as np
+import PIL.Image
+from gradio_client.utils import is_http_url_like
+
+from gradio import processing_utils, utils, wasm_utils
+from gradio.data_classes import FileData
+
+from gradio.events import Dependency
+
+class Gallery(gradio.Gallery):
+    def postprocess(
+        self,
+        value: list[GalleryImageType | CaptionedGalleryImageType] | None,
+    ) -> GalleryData:
+        """
+        This is a patched version of the original function, wherein the format for PIL is computed based on the data type:
+        format = "png" if img.mode == "I;16" else "webp"
+        """
+        if value is None:
+            return GalleryData(root=[])
+        output = []
+
+        def _save(img):
+            url = None
+            caption = None
+            orig_name = None
+            if isinstance(img, (tuple, list)):
+                img, caption = img
+            if isinstance(img, np.ndarray):
+                file = processing_utils.save_img_array_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=self.format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, PIL.Image.Image):
+                format = "png" #if img.mode == "I;16" else "webp"
+                file = processing_utils.save_pil_to_cache(
+                    img, cache_dir=self.GRADIO_CACHE, format=format
+                )
+                file_path = str(utils.abspath(file))
+            elif isinstance(img, str):
+                file_path = img
+                if is_http_url_like(img):
+                    url = img
+                    orig_name = Path(urlparse(img).path).name
+                else:
+                    url = None
+                    orig_name = Path(img).name
+            elif isinstance(img, Path):
+                file_path = str(img)
+                orig_name = img.name
+            else:
+                raise ValueError(f"Cannot process type as image: {type(img)}")
+            return GalleryImage(
+                image=FileData(path=file_path, url=url, orig_name=orig_name),
+                caption=caption,
+            )
+
+        if wasm_utils.IS_WASM:
+            for img in value:
+                output.append(_save(img))
+        else:
+            with ThreadPoolExecutor() as executor:
+                for o in executor.map(_save, value):
+                    output.append(o)
+        return GalleryData(root=output)
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer

gradio_dualvision/gradio_patches/imagesliderplus.py

@@ -0,0 +1,156 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import json
+import os.path
+import tempfile
+from pathlib import Path
+from typing import Union, Tuple, Optional
+
+import numpy as np
+from PIL import Image
+from gradio import processing_utils
+from gradio import utils
+from gradio.data_classes import FileData, GradioRootModel, JsonData
+from gradio_client import utils as client_utils
+from gradio_imageslider import ImageSlider
+from gradio_imageslider.imageslider import image_tuple, image_variants
+
+
+class ImageSliderPlusData(GradioRootModel):
+    root: Union[
+        Tuple[FileData | None, FileData | None, JsonData | None],
+        Tuple[FileData | None, FileData | None],
+        None,
+    ]
+
+
+class ImageSliderPlus(ImageSlider):
+    data_model = ImageSliderPlusData
+
+    def as_example(self, value):
+        return self.process_example_dims(value, 256, True)
+
+    def _format_image(self, im: Image):
+        if self.type != "filepath":
+            raise ValueError("ImageSliderPlus can be only created with type='filepath'")
+        if im is None:
+            return im
+        format = "png" #if im.mode == "I;16" else "webp"
+        path = processing_utils.save_pil_to_cache(
+            im, cache_dir=self.GRADIO_CACHE, format=format
+        )
+        self.temp_files.add(path)
+        return path
+
+    def _postprocess_image(self, y: image_variants):
+        if isinstance(y, np.ndarray):
+            format = "png" #if y.dtype == np.uint16 and y.squeeze().ndim == 2 else "webp"
+            path = processing_utils.save_img_array_to_cache(
+                y, cache_dir=self.GRADIO_CACHE, format=format
+            )
+        elif isinstance(y, Image.Image):
+            format = "png" #if y.mode == "I;16" else "webp"
+            path = processing_utils.save_pil_to_cache(
+                y, cache_dir=self.GRADIO_CACHE, format=format
+            )
+        elif isinstance(y, (str, Path)):
+            path = y if isinstance(y, str) else str(utils.abspath(y))
+        else:
+            raise ValueError("Cannot process this value as an Image")
+
+        return path
+
+    def postprocess(
+        self,
+        y: image_tuple,
+    ) -> ImageSliderPlusData:
+        if y is None:
+            return ImageSliderPlusData(root=(None, None, None))
+
+        settings = None
+        if type(y[0]) is str:
+            settings_candidate_path = y[0] + ".settings.json"
+            if os.path.isfile(settings_candidate_path):
+                with open(settings_candidate_path, "r") as fp:
+                    settings = json.load(fp)
+
+        return ImageSliderPlusData(
+            root=(
+                FileData(path=self._postprocess_image(y[0])),
+                FileData(path=self._postprocess_image(y[1])),
+                JsonData(settings),
+            ),
+        )
+
+    def preprocess(self, x: ImageSliderPlusData) -> image_tuple:
+        if x is None:
+            return x
+
+        out_0 = self._preprocess_image(x.root[0])
+        out_1 = self._preprocess_image(x.root[1])
+
+        if len(x.root) > 2 and x.root[2] is not None:
+            with open(out_0 + ".settings.json", "w") as fp:
+                json.dump(x.root[2].root, fp)
+
+        return out_0, out_1
+
+    @staticmethod
+    def resize_and_save(image_path: str, max_dim: int, square: bool = False) -> str:
+        img = Image.open(image_path).convert("RGB")
+        if square:
+            width, height = img.size
+            min_side = min(width, height)
+            left = (width - min_side) // 2
+            top = (height - min_side) // 2
+            right = left + min_side
+            bottom = top + min_side
+            img = img.crop((left, top, right, bottom))
+        img.thumbnail((max_dim, max_dim))
+        temp_file = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+        img.save(temp_file.name, "PNG")
+        return temp_file.name
+
+    def process_example_dims(
+        self, input_data: tuple[str | Path | None] | None, max_dim: Optional[int] = None, square: bool = False
+    ) -> image_tuple:
+        if input_data is None:
+            return None
+        input_data = (str(input_data[0]), str(input_data[1]))
+        if self.proxy_url or client_utils.is_http_url_like(input_data[0]):
+            return input_data[0]
+        if max_dim is not None:
+            input_data = (
+                self.resize_and_save(input_data[0], max_dim, square),
+                self.resize_and_save(input_data[1], max_dim, square),
+            )
+        return (
+            self.move_resource_to_block_cache(input_data[0]),
+            self.move_resource_to_block_cache(input_data[1]),
+        )
+
+    def process_example(
+        self, input_data: tuple[str | Path | None] | None
+    ) -> image_tuple:
+        return self.process_example_dims(input_data)

gradio_dualvision/gradio_patches/imagesliderplus.pyi

@@ -0,0 +1,161 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import json
+import os.path
+import tempfile
+from pathlib import Path
+from typing import Union, Tuple, Optional
+
+import numpy as np
+from PIL import Image
+from gradio import processing_utils
+from gradio import utils
+from gradio.data_classes import FileData, GradioRootModel, JsonData
+from gradio_client import utils as client_utils
+from gradio_imageslider import ImageSlider
+from gradio_imageslider.imageslider import image_tuple, image_variants
+
+
+class ImageSliderPlusData(GradioRootModel):
+    root: Union[
+        Tuple[FileData | None, FileData | None, JsonData | None],
+        Tuple[FileData | None, FileData | None],
+        None,
+    ]
+
+from gradio.events import Dependency
+
+class ImageSliderPlus(ImageSlider):
+    data_model = ImageSliderPlusData
+
+    def as_example(self, value):
+        return self.process_example_dims(value, 256, True)
+
+    def _format_image(self, im: Image):
+        if self.type != "filepath":
+            raise ValueError("ImageSliderPlus can be only created with type='filepath'")
+        if im is None:
+            return im
+        format = "png" #if im.mode == "I;16" else "webp"
+        path = processing_utils.save_pil_to_cache(
+            im, cache_dir=self.GRADIO_CACHE, format=format
+        )
+        self.temp_files.add(path)
+        return path
+
+    def _postprocess_image(self, y: image_variants):
+        if isinstance(y, np.ndarray):
+            format = "png" #if y.dtype == np.uint16 and y.squeeze().ndim == 2 else "webp"
+            path = processing_utils.save_img_array_to_cache(
+                y, cache_dir=self.GRADIO_CACHE, format=format
+            )
+        elif isinstance(y, Image.Image):
+            format = "png" #if y.mode == "I;16" else "webp"
+            path = processing_utils.save_pil_to_cache(
+                y, cache_dir=self.GRADIO_CACHE, format=format
+            )
+        elif isinstance(y, (str, Path)):
+            path = y if isinstance(y, str) else str(utils.abspath(y))
+        else:
+            raise ValueError("Cannot process this value as an Image")
+
+        return path
+
+    def postprocess(
+        self,
+        y: image_tuple,
+    ) -> ImageSliderPlusData:
+        if y is None:
+            return ImageSliderPlusData(root=(None, None, None))
+
+        settings = None
+        if type(y[0]) is str:
+            settings_candidate_path = y[0] + ".settings.json"
+            if os.path.isfile(settings_candidate_path):
+                with open(settings_candidate_path, "r") as fp:
+                    settings = json.load(fp)
+
+        return ImageSliderPlusData(
+            root=(
+                FileData(path=self._postprocess_image(y[0])),
+                FileData(path=self._postprocess_image(y[1])),
+                JsonData(settings),
+            ),
+        )
+
+    def preprocess(self, x: ImageSliderPlusData) -> image_tuple:
+        if x is None:
+            return x
+
+        out_0 = self._preprocess_image(x.root[0])
+        out_1 = self._preprocess_image(x.root[1])
+
+        if len(x.root) > 2 and x.root[2] is not None:
+            with open(out_0 + ".settings.json", "w") as fp:
+                json.dump(x.root[2].root, fp)
+
+        return out_0, out_1
+
+    @staticmethod
+    def resize_and_save(image_path: str, max_dim: int, square: bool = False) -> str:
+        img = Image.open(image_path).convert("RGB")
+        if square:
+            width, height = img.size
+            min_side = min(width, height)
+            left = (width - min_side) // 2
+            top = (height - min_side) // 2
+            right = left + min_side
+            bottom = top + min_side
+            img = img.crop((left, top, right, bottom))
+        img.thumbnail((max_dim, max_dim))
+        temp_file = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+        img.save(temp_file.name, "PNG")
+        return temp_file.name
+
+    def process_example_dims(
+        self, input_data: tuple[str | Path | None] | None, max_dim: Optional[int] = None, square: bool = False
+    ) -> image_tuple:
+        if input_data is None:
+            return None
+        input_data = (str(input_data[0]), str(input_data[1]))
+        if self.proxy_url or client_utils.is_http_url_like(input_data[0]):
+            return input_data[0]
+        if max_dim is not None:
+            input_data = (
+                self.resize_and_save(input_data[0], max_dim, square),
+                self.resize_and_save(input_data[1], max_dim, square),
+            )
+        return (
+            self.move_resource_to_block_cache(input_data[0]),
+            self.move_resource_to_block_cache(input_data[1]),
+        )
+
+    def process_example(
+        self, input_data: tuple[str | Path | None] | None
+    ) -> image_tuple:
+        return self.process_example_dims(input_data)
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer

gradio_dualvision/gradio_patches/radio.py

@@ -0,0 +1,62 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import gradio
+from gradio import components
+from gradio.components.base import Component
+from gradio.data_classes import (
+    GradioModel,
+    GradioRootModel,
+)
+
+from gradio.blocks import BlockContext
+
+
+def patched_postprocess_update_dict(
+    block: Component | BlockContext, update_dict: dict, postprocess: bool = True
+):
+    """
+    This is a patched version of the original function where 'pop' is replaced with 'get' in the first line.
+    The key will no longer be removed but can still be accessed safely.
+    This fixed gradio.Radio component persisting the value selection through gradio.Examples.
+    """
+    value = update_dict.get("value", components._Keywords.NO_VALUE)
+
+    # Continue with the original logic
+    update_dict = {k: getattr(block, k) for k in update_dict if hasattr(block, k)}
+    if value is not components._Keywords.NO_VALUE:
+        if postprocess:
+            update_dict["value"] = block.postprocess(value)
+            if isinstance(update_dict["value"], (GradioModel, GradioRootModel)):
+                update_dict["value"] = update_dict["value"].model_dump()
+        else:
+            update_dict["value"] = value
+    update_dict["__type__"] = "update"
+    return update_dict
+
+
+gradio.blocks.postprocess_update_dict = patched_postprocess_update_dict
+
+
+class Radio(gradio.Radio):
+    pass

gradio_dualvision/gradio_patches/radio.pyi

@@ -0,0 +1,67 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+import gradio
+from gradio import components
+from gradio.components.base import Component
+from gradio.data_classes import (
+    GradioModel,
+    GradioRootModel,
+)
+
+from gradio.blocks import BlockContext
+
+
+def patched_postprocess_update_dict(
+    block: Component | BlockContext, update_dict: dict, postprocess: bool = True
+):
+    """
+    This is a patched version of the original function where 'pop' is replaced with 'get' in the first line.
+    The key will no longer be removed but can still be accessed safely.
+    This fixed gradio.Radio component persisting the value selection through gradio.Examples.
+    """
+    value = update_dict.get("value", components._Keywords.NO_VALUE)
+
+    # Continue with the original logic
+    update_dict = {k: getattr(block, k) for k in update_dict if hasattr(block, k)}
+    if value is not components._Keywords.NO_VALUE:
+        if postprocess:
+            update_dict["value"] = block.postprocess(value)
+            if isinstance(update_dict["value"], (GradioModel, GradioRootModel)):
+                update_dict["value"] = update_dict["value"].model_dump()
+        else:
+            update_dict["value"] = value
+    update_dict["__type__"] = "update"
+    return update_dict
+
+
+gradio.blocks.postprocess_update_dict = patched_postprocess_update_dict
+
+from gradio.events import Dependency
+
+class Radio(gradio.Radio):
+    pass
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer

gradio_dualvision/gradio_patches/templates/component/__vite-browser-external-2447137e.js

@@ -0,0 +1,4 @@
+const e = {};
+export {
+  e as default
+};

gradio_dualvision/gradio_patches/templates/component/style.css

@@ -0,0 +1 @@
+.wrap.svelte-1w37x6c.svelte-1w37x6c{position:relative;width:100%;height:100%;z-index:100}.icon-wrap.svelte-1w37x6c.svelte-1w37x6c{position:absolute;top:50%;transform:translateY(-50%);left:-40px;width:32px;transition:.2s;color:var(--body-text-color)}.icon-wrap.right.svelte-1w37x6c.svelte-1w37x6c{left:60px;transform:translateY(-50%) translate(-100%) rotate(180deg)}.icon-wrap.active.svelte-1w37x6c.svelte-1w37x6c,.icon-wrap.disabled.svelte-1w37x6c.svelte-1w37x6c{opacity:0}.outer.svelte-1w37x6c.svelte-1w37x6c{width:20px;height:100%;cursor:grab;position:absolute;top:0;left:0}.inner.svelte-1w37x6c.svelte-1w37x6c{box-shadow:-1px 0 6px 1px #0003;width:1px;height:100%;background:var(--color);position:absolute;left:calc((100% - 2px)/2)}.disabled.svelte-1w37x6c.svelte-1w37x6c{cursor:auto}.disabled.svelte-1w37x6c .inner.svelte-1w37x6c{box-shadow:none}.block.svelte-1t38q2d{position:relative;margin:0;box-shadow:var(--block-shadow);border-width:var(--block-border-width);border-color:var(--block-border-color);border-radius:var(--block-radius);background:var(--block-background-fill);width:100%;line-height:var(--line-sm)}.block.border_focus.svelte-1t38q2d{border-color:var(--color-accent)}.padded.svelte-1t38q2d{padding:var(--block-padding)}.hidden.svelte-1t38q2d{display:none}.hide-container.svelte-1t38q2d{margin:0;box-shadow:none;--block-border-width:0;background:transparent;padding:0;overflow:visible}div.svelte-1hnfib2{margin-bottom:var(--spacing-lg);color:var(--block-info-text-color);font-weight:var(--block-info-text-weight);font-size:var(--block-info-text-size);line-height:var(--line-sm)}span.has-info.svelte-22c38v{margin-bottom:var(--spacing-xs)}span.svelte-22c38v:not(.has-info){margin-bottom:var(--spacing-lg)}span.svelte-22c38v{display:inline-block;position:relative;z-index:var(--layer-4);border:solid var(--block-title-border-width) var(--block-title-border-color);border-radius:var(--block-title-radius);background:var(--block-title-background-fill);padding:var(--block-title-padding);color:var(--block-title-text-color);font-weight:var(--block-title-text-weight);font-size:var(--block-title-text-size);line-height:var(--line-sm)}.hide.svelte-22c38v{margin:0;height:0}label.svelte-9gxdi0{display:inline-flex;align-items:center;z-index:var(--layer-2);box-shadow:var(--block-label-shadow);border:var(--block-label-border-width) solid var(--border-color-primary);border-top:none;border-left:none;border-radius:var(--block-label-radius);background:var(--block-label-background-fill);padding:var(--block-label-padding);pointer-events:none;color:var(--block-label-text-color);font-weight:var(--block-label-text-weight);font-size:var(--block-label-text-size);line-height:var(--line-sm)}.gr-group label.svelte-9gxdi0{border-top-left-radius:0}label.float.svelte-9gxdi0{position:absolute;top:var(--block-label-margin);left:var(--block-label-margin)}label.svelte-9gxdi0:not(.float){position:static;margin-top:var(--block-label-margin);margin-left:var(--block-label-margin)}.hide.svelte-9gxdi0{height:0}span.svelte-9gxdi0{opacity:.8;margin-right:var(--size-2);width:calc(var(--block-label-text-size) - 1px);height:calc(var(--block-label-text-size) - 1px)}.hide-label.svelte-9gxdi0{box-shadow:none;border-width:0;background:transparent;overflow:visible}button.svelte-lpi64a{display:flex;justify-content:center;align-items:center;gap:1px;z-index:var(--layer-2);border-radius:var(--radius-sm);color:var(--block-label-text-color);border:1px solid transparent}button[disabled].svelte-lpi64a{opacity:.5;box-shadow:none}button[disabled].svelte-lpi64a:hover{cursor:not-allowed}.padded.svelte-lpi64a{padding:2px;background:var(--bg-color);box-shadow:var(--shadow-drop);border:1px solid var(--button-secondary-border-color)}button.svelte-lpi64a:hover,button.highlight.svelte-lpi64a{cursor:pointer;color:var(--color-accent)}.padded.svelte-lpi64a:hover{border:2px solid var(--button-secondary-border-color-hover);padding:1px;color:var(--block-label-text-color)}span.svelte-lpi64a{padding:0 1px;font-size:10px}div.svelte-lpi64a{padding:2px;display:flex;align-items:flex-end}.small.svelte-lpi64a{width:14px;height:14px}.large.svelte-lpi64a{width:22px;height:22px}.pending.svelte-lpi64a{animation:svelte-lpi64a-flash .5s infinite}@keyframes svelte-lpi64a-flash{0%{opacity:.5}50%{opacity:1}to{opacity:.5}}.transparent.svelte-lpi64a{background:transparent;border:none;box-shadow:none}.empty.svelte-3w3rth{display:flex;justify-content:center;align-items:center;margin-top:calc(0px - var(--size-6));height:var(--size-full)}.icon.svelte-3w3rth{opacity:.5;height:var(--size-5);color:var(--body-text-color)}.small.svelte-3w3rth{min-height:calc(var(--size-32) - 20px)}.large.svelte-3w3rth{min-height:calc(var(--size-64) - 20px)}.unpadded_box.svelte-3w3rth{margin-top:0}.small_parent.svelte-3w3rth{min-height:100%!important}.dropdown-arrow.svelte-145leq6{fill:currentColor}.wrap.svelte-kzcjhc{display:flex;flex-direction:column;justify-content:center;align-items:center;min-height:var(--size-60);color:var(--block-label-text-color);line-height:var(--line-md);height:100%;padding-top:var(--size-3)}.or.svelte-kzcjhc{color:var(--body-text-color-subdued);display:flex}.icon-wrap.svelte-kzcjhc{width:30px;margin-bottom:var(--spacing-lg)}@media (--screen-md){.wrap.svelte-kzcjhc{font-size:var(--text-lg)}}.hovered.svelte-kzcjhc{color:var(--color-accent)}div.svelte-ipfyu7{border-top:1px solid transparent;display:flex;max-height:100%;justify-content:center;gap:var(--spacing-sm);height:auto;align-items:flex-end;padding-bottom:var(--spacing-xl);color:var(--block-label-text-color);flex-shrink:0;width:95%}.show_border.svelte-ipfyu7{border-top:1px solid var(--block-border-color);margin-top:var(--spacing-xxl);box-shadow:var(--shadow-drop)}.source-selection.svelte-lde7lt{display:flex;align-items:center;justify-content:center;border-top:1px solid var(--border-color-primary);width:95%;bottom:0;left:0;right:0;margin-left:auto;margin-right:auto;align-self:flex-end}.icon.svelte-lde7lt{width:22px;height:22px;margin:var(--spacing-lg) var(--spacing-xs);padding:var(--spacing-xs);color:var(--neutral-400);border-radius:var(--radius-md)}.selected.svelte-lde7lt{color:var(--color-accent)}.icon.svelte-lde7lt:hover,.icon.svelte-lde7lt:focus{color:var(--color-accent)}div.svelte-1g74h68{display:flex;position:absolute;top:var(--size-2);right:var(--size-2);justify-content:flex-end;gap:var(--spacing-sm);z-index:var(--layer-5)}.wrap.svelte-1juivz4.svelte-1juivz4{overflow-y:auto;transition:opacity .5s ease-in-out;background:var(--block-background-fill);position:relative;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:var(--size-40);width:100%}.wrap.svelte-1juivz4.svelte-1juivz4:after{content:"";position:absolute;top:0;left:0;width:var(--upload-progress-width);height:100%;transition:all .5s ease-in-out;z-index:1}.uploading.svelte-1juivz4.svelte-1juivz4{font-size:var(--text-lg);font-family:var(--font);z-index:2}.file-name.svelte-1juivz4.svelte-1juivz4{margin:var(--spacing-md);font-size:var(--text-lg);color:var(--body-text-color-subdued)}.file.svelte-1juivz4.svelte-1juivz4{font-size:var(--text-md);z-index:2;display:flex;align-items:center}.file.svelte-1juivz4 progress.svelte-1juivz4{display:inline;height:var(--size-1);width:100%;transition:all .5s ease-in-out;color:var(--color-accent);border:none}.file.svelte-1juivz4 progress[value].svelte-1juivz4::-webkit-progress-value{background-color:var(--color-accent);border-radius:20px}.file.svelte-1juivz4 progress[value].svelte-1juivz4::-webkit-progress-bar{background-color:var(--border-color-accent);border-radius:20px}.progress-bar.svelte-1juivz4.svelte-1juivz4{width:14px;height:14px;border-radius:50%;background:radial-gradient(closest-side,var(--block-background-fill) 64%,transparent 53% 100%),conic-gradient(var(--color-accent) var(--upload-progress-width),var(--border-color-accent) 0);transition:all .5s ease-in-out}button.svelte-1aq8tno{cursor:pointer;width:var(--size-full)}.hidden.svelte-1aq8tno{display:none;height:0!important;position:absolute;width:0;flex-grow:0}.center.svelte-1aq8tno{display:flex;justify-content:center}.flex.svelte-1aq8tno{display:flex;justify-content:center;align-items:center}input.svelte-1aq8tno{display:none}div.svelte-1wj0ocy{display:flex;top:var(--size-2);right:var(--size-2);justify-content:flex-end;gap:var(--spacing-sm);z-index:var(--layer-1)}.not-absolute.svelte-1wj0ocy{margin:var(--size-1)}.upload-wrap.svelte-106mu0e.svelte-106mu0e{display:flex;justify-content:center;align-items:center;height:100%;width:100%}.wrap.svelte-106mu0e.svelte-106mu0e{width:100%}.half-wrap.svelte-106mu0e.svelte-106mu0e{width:50%}.image-container.svelte-106mu0e.svelte-106mu0e,img.svelte-106mu0e.svelte-106mu0e,.empty-wrap.svelte-106mu0e.svelte-106mu0e{width:var(--size-full);height:var(--size-full)}img.svelte-106mu0e.svelte-106mu0e{object-fit:cover}.fixed.svelte-106mu0e.svelte-106mu0e{--anim-block-background-fill:255, 255, 255;position:absolute;top:0;left:0;background-color:rgba(var(--anim-block-background-fill),.8);z-index:0}@media (prefers-color-scheme: dark){.fixed.svelte-106mu0e.svelte-106mu0e{--anim-block-background-fill:31, 41, 55}}.side-by-side.svelte-106mu0e img.svelte-106mu0e{width:50%;object-fit:contain}.empty-wrap.svelte-106mu0e.svelte-106mu0e{pointer-events:none}.icon-buttons.svelte-106mu0e.svelte-106mu0e{display:flex;position:absolute;right:8px;z-index:var(--layer-top);top:8px}svg.svelte-43sxxs.svelte-43sxxs{width:var(--size-20);height:var(--size-20)}svg.svelte-43sxxs path.svelte-43sxxs{fill:var(--loader-color)}div.svelte-43sxxs.svelte-43sxxs{z-index:var(--layer-2)}.margin.svelte-43sxxs.svelte-43sxxs{margin:var(--size-4)}.wrap.svelte-1txqlrd.svelte-1txqlrd{display:flex;flex-direction:column;justify-content:center;align-items:center;z-index:var(--layer-top);transition:opacity .1s ease-in-out;border-radius:var(--block-radius);background:var(--block-background-fill);padding:0 var(--size-6);max-height:var(--size-screen-h);overflow:hidden;pointer-events:none}.wrap.center.svelte-1txqlrd.svelte-1txqlrd{top:0;right:0;left:0}.wrap.default.svelte-1txqlrd.svelte-1txqlrd{top:0;right:0;bottom:0;left:0}.hide.svelte-1txqlrd.svelte-1txqlrd{opacity:0;pointer-events:none}.generating.svelte-1txqlrd.svelte-1txqlrd{animation:svelte-1txqlrd-pulse 2s cubic-bezier(.4,0,.6,1) infinite;border:2px solid var(--color-accent);background:transparent}.translucent.svelte-1txqlrd.svelte-1txqlrd{background:none}@keyframes svelte-1txqlrd-pulse{0%,to{opacity:1}50%{opacity:.5}}.loading.svelte-1txqlrd.svelte-1txqlrd{z-index:var(--layer-2);color:var(--body-text-color)}.eta-bar.svelte-1txqlrd.svelte-1txqlrd{position:absolute;top:0;right:0;bottom:0;left:0;transform-origin:left;opacity:.8;z-index:var(--layer-1);transition:10ms;background:var(--background-fill-secondary)}.progress-bar-wrap.svelte-1txqlrd.svelte-1txqlrd{border:1px solid var(--border-color-primary);background:var(--background-fill-primary);width:55.5%;height:var(--size-4)}.progress-bar.svelte-1txqlrd.svelte-1txqlrd{transform-origin:left;background-color:var(--loader-color);width:var(--size-full);height:var(--size-full)}.progress-level.svelte-1txqlrd.svelte-1txqlrd{display:flex;flex-direction:column;align-items:center;gap:1;z-index:var(--layer-2);width:var(--size-full)}.progress-level-inner.svelte-1txqlrd.svelte-1txqlrd{margin:var(--size-2) auto;color:var(--body-text-color);font-size:var(--text-sm);font-family:var(--font-mono)}.meta-text.svelte-1txqlrd.svelte-1txqlrd{position:absolute;top:0;right:0;z-index:var(--layer-2);padding:var(--size-1) var(--size-2);font-size:var(--text-sm);font-family:var(--font-mono)}.meta-text-center.svelte-1txqlrd.svelte-1txqlrd{display:flex;position:absolute;top:0;right:0;justify-content:center;align-items:center;transform:translateY(var(--size-6));z-index:var(--layer-2);padding:var(--size-1) var(--size-2);font-size:var(--text-sm);font-family:var(--font-mono);text-align:center}.error.svelte-1txqlrd.svelte-1txqlrd{box-shadow:var(--shadow-drop);border:solid 1px var(--error-border-color);border-radius:var(--radius-full);background:var(--error-background-fill);padding-right:var(--size-4);padding-left:var(--size-4);color:var(--error-text-color);font-weight:var(--weight-semibold);font-size:var(--text-lg);line-height:var(--line-lg);font-family:var(--font)}.minimal.svelte-1txqlrd .progress-text.svelte-1txqlrd{background:var(--block-background-fill)}.border.svelte-1txqlrd.svelte-1txqlrd{border:1px solid var(--border-color-primary)}.toast-body.svelte-solcu7{display:flex;position:relative;right:0;left:0;align-items:center;margin:var(--size-6) var(--size-4);margin:auto;border-radius:var(--container-radius);overflow:hidden;pointer-events:auto}.toast-body.error.svelte-solcu7{border:1px solid var(--color-red-700);background:var(--color-red-50)}.dark .toast-body.error.svelte-solcu7{border:1px solid var(--color-red-500);background-color:var(--color-grey-950)}.toast-body.warning.svelte-solcu7{border:1px solid var(--color-yellow-700);background:var(--color-yellow-50)}.dark .toast-body.warning.svelte-solcu7{border:1px solid var(--color-yellow-500);background-color:var(--color-grey-950)}.toast-body.info.svelte-solcu7{border:1px solid var(--color-grey-700);background:var(--color-grey-50)}.dark .toast-body.info.svelte-solcu7{border:1px solid var(--color-grey-500);background-color:var(--color-grey-950)}.toast-title.svelte-solcu7{display:flex;align-items:center;font-weight:var(--weight-bold);font-size:var(--text-lg);line-height:var(--line-sm);text-transform:capitalize}.toast-title.error.svelte-solcu7{color:var(--color-red-700)}.dark .toast-title.error.svelte-solcu7{color:var(--color-red-50)}.toast-title.warning.svelte-solcu7{color:var(--color-yellow-700)}.dark .toast-title.warning.svelte-solcu7{color:var(--color-yellow-50)}.toast-title.info.svelte-solcu7{color:var(--color-grey-700)}.dark .toast-title.info.svelte-solcu7{color:var(--color-grey-50)}.toast-close.svelte-solcu7{margin:0 var(--size-3);border-radius:var(--size-3);padding:0px var(--size-1-5);font-size:var(--size-5);line-height:var(--size-5)}.toast-close.error.svelte-solcu7{color:var(--color-red-700)}.dark .toast-close.error.svelte-solcu7{color:var(--color-red-500)}.toast-close.warning.svelte-solcu7{color:var(--color-yellow-700)}.dark .toast-close.warning.svelte-solcu7{color:var(--color-yellow-500)}.toast-close.info.svelte-solcu7{color:var(--color-grey-700)}.dark .toast-close.info.svelte-solcu7{color:var(--color-grey-500)}.toast-text.svelte-solcu7{font-size:var(--text-lg)}.toast-text.error.svelte-solcu7{color:var(--color-red-700)}.dark .toast-text.error.svelte-solcu7{color:var(--color-red-50)}.toast-text.warning.svelte-solcu7{color:var(--color-yellow-700)}.dark .toast-text.warning.svelte-solcu7{color:var(--color-yellow-50)}.toast-text.info.svelte-solcu7{color:var(--color-grey-700)}.dark .toast-text.info.svelte-solcu7{color:var(--color-grey-50)}.toast-details.svelte-solcu7{margin:var(--size-3) var(--size-3) var(--size-3) 0;width:100%}.toast-icon.svelte-solcu7{display:flex;position:absolute;position:relative;flex-shrink:0;justify-content:center;align-items:center;margin:var(--size-2);border-radius:var(--radius-full);padding:var(--size-1);padding-left:calc(var(--size-1) - 1px);width:35px;height:35px}.toast-icon.error.svelte-solcu7{color:var(--color-red-700)}.dark .toast-icon.error.svelte-solcu7{color:var(--color-red-500)}.toast-icon.warning.svelte-solcu7{color:var(--color-yellow-700)}.dark .toast-icon.warning.svelte-solcu7{color:var(--color-yellow-500)}.toast-icon.info.svelte-solcu7{color:var(--color-grey-700)}.dark .toast-icon.info.svelte-solcu7{color:var(--color-grey-500)}@keyframes svelte-solcu7-countdown{0%{transform:scaleX(1)}to{transform:scaleX(0)}}.timer.svelte-solcu7{position:absolute;bottom:0;left:0;transform-origin:0 0;animation:svelte-solcu7-countdown 10s linear forwards;width:100%;height:var(--size-1)}.timer.error.svelte-solcu7{background:var(--color-red-700)}.dark .timer.error.svelte-solcu7{background:var(--color-red-500)}.timer.warning.svelte-solcu7{background:var(--color-yellow-700)}.dark .timer.warning.svelte-solcu7{background:var(--color-yellow-500)}.timer.info.svelte-solcu7{background:var(--color-grey-700)}.dark .timer.info.svelte-solcu7{background:var(--color-grey-500)}.toast-wrap.svelte-gatr8h{display:flex;position:fixed;top:var(--size-4);right:var(--size-4);flex-direction:column;align-items:end;gap:var(--size-2);z-index:var(--layer-top);width:calc(100% - var(--size-8))}@media (--screen-sm){.toast-wrap.svelte-gatr8h{width:calc(var(--size-96) + var(--size-10))}}.slider-wrap.svelte-a2zf8o{-webkit-user-select:none;user-select:none;max-height:calc(100vh - 40px)}img.svelte-a2zf8o{width:var(--size-full);height:var(--size-full);object-fit:cover}.fixed.svelte-a2zf8o{position:absolute;top:0;left:0}.hidden.svelte-a2zf8o{opacity:0}.icon-buttons.svelte-a2zf8o{display:flex;position:absolute;right:8px;z-index:var(--layer-top);top:8px}.status-wrap.svelte-6wvohu{position:absolute;height:100%;width:100%;--anim-block-background-fill:255, 255, 255;z-index:1;pointer-events:none}@media (prefers-color-scheme: dark){.status-wrap.svelte-6wvohu{--anim-block-background-fill:31, 41, 55}}@keyframes svelte-6wvohu-pulse{0%{background-color:rgba(var(--anim-block-background-fill),.7)}50%{background-color:rgba(var(--anim-block-background-fill),.4)}to{background-color:rgba(var(--anim-block-background-fill),.7)}}.status-wrap.half.svelte-6wvohu .wrap{border-radius:0;animation:svelte-6wvohu-pulse 1.4s infinite ease-in-out}.status-wrap.half.svelte-6wvohu .progress-text{background:none!important}.status-wrap.half.svelte-6wvohu .eta-bar{opacity:0}.icon-buttons.svelte-6wvohu{display:flex;position:absolute;right:6px;z-index:var(--layer-1);top:6px}

gradio_dualvision/gradio_patches/templates/component/wrapper-6f348d45-19fa94bf.js

@@ -0,0 +1,2453 @@
+import S from "./__vite-browser-external-2447137e.js";
+function z(s) {
+  return s && s.__esModule && Object.prototype.hasOwnProperty.call(s, "default") ? s.default : s;
+}
+function gt(s) {
+  if (s.__esModule)
+    return s;
+  var e = s.default;
+  if (typeof e == "function") {
+    var t = function r() {
+      if (this instanceof r) {
+        var i = [null];
+        i.push.apply(i, arguments);
+        var n = Function.bind.apply(e, i);
+        return new n();
+      }
+      return e.apply(this, arguments);
+    };
+    t.prototype = e.prototype;
+  } else
+    t = {};
+  return Object.defineProperty(t, "__esModule", { value: !0 }), Object.keys(s).forEach(function(r) {
+    var i = Object.getOwnPropertyDescriptor(s, r);
+    Object.defineProperty(t, r, i.get ? i : {
+      enumerable: !0,
+      get: function() {
+        return s[r];
+      }
+    });
+  }), t;
+}
+const { Duplex: yt } = S;
+function Oe(s) {
+  s.emit("close");
+}
+function vt() {
+  !this.destroyed && this._writableState.finished && this.destroy();
+}
+function Qe(s) {
+  this.removeListener("error", Qe), this.destroy(), this.listenerCount("error") === 0 && this.emit("error", s);
+}
+function St(s, e) {
+  let t = !0;
+  const r = new yt({
+    ...e,
+    autoDestroy: !1,
+    emitClose: !1,
+    objectMode: !1,
+    writableObjectMode: !1
+  });
+  return s.on("message", function(n, o) {
+    const l = !o && r._readableState.objectMode ? n.toString() : n;
+    r.push(l) || s.pause();
+  }), s.once("error", function(n) {
+    r.destroyed || (t = !1, r.destroy(n));
+  }), s.once("close", function() {
+    r.destroyed || r.push(null);
+  }), r._destroy = function(i, n) {
+    if (s.readyState === s.CLOSED) {
+      n(i), process.nextTick(Oe, r);
+      return;
+    }
+    let o = !1;
+    s.once("error", function(f) {
+      o = !0, n(f);
+    }), s.once("close", function() {
+      o || n(i), process.nextTick(Oe, r);
+    }), t && s.terminate();
+  }, r._final = function(i) {
+    if (s.readyState === s.CONNECTING) {
+      s.once("open", function() {
+        r._final(i);
+      });
+      return;
+    }
+    s._socket !== null && (s._socket._writableState.finished ? (i(), r._readableState.endEmitted && r.destroy()) : (s._socket.once("finish", function() {
+      i();
+    }), s.close()));
+  }, r._read = function() {
+    s.isPaused && s.resume();
+  }, r._write = function(i, n, o) {
+    if (s.readyState === s.CONNECTING) {
+      s.once("open", function() {
+        r._write(i, n, o);
+      });
+      return;
+    }
+    s.send(i, o);
+  }, r.on("end", vt), r.on("error", Qe), r;
+}
+var Et = St;
+const Vs = /* @__PURE__ */ z(Et);
+var te = { exports: {} }, U = {
+  BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
+  EMPTY_BUFFER: Buffer.alloc(0),
+  GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
+  kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
+  kListener: Symbol("kListener"),
+  kStatusCode: Symbol("status-code"),
+  kWebSocket: Symbol("websocket"),
+  NOOP: () => {
+  }
+}, bt, xt;
+const { EMPTY_BUFFER: kt } = U, Se = Buffer[Symbol.species];
+function wt(s, e) {
+  if (s.length === 0)
+    return kt;
+  if (s.length === 1)
+    return s[0];
+  const t = Buffer.allocUnsafe(e);
+  let r = 0;
+  for (let i = 0; i < s.length; i++) {
+    const n = s[i];
+    t.set(n, r), r += n.length;
+  }
+  return r < e ? new Se(t.buffer, t.byteOffset, r) : t;
+}
+function Je(s, e, t, r, i) {
+  for (let n = 0; n < i; n++)
+    t[r + n] = s[n] ^ e[n & 3];
+}
+function et(s, e) {
+  for (let t = 0; t < s.length; t++)
+    s[t] ^= e[t & 3];
+}
+function Ot(s) {
+  return s.length === s.buffer.byteLength ? s.buffer : s.buffer.slice(s.byteOffset, s.byteOffset + s.length);
+}
+function Ee(s) {
+  if (Ee.readOnly = !0, Buffer.isBuffer(s))
+    return s;
+  let e;
+  return s instanceof ArrayBuffer ? e = new Se(s) : ArrayBuffer.isView(s) ? e = new Se(s.buffer, s.byteOffset, s.byteLength) : (e = Buffer.from(s), Ee.readOnly = !1), e;
+}
+te.exports = {
+  concat: wt,
+  mask: Je,
+  toArrayBuffer: Ot,
+  toBuffer: Ee,
+  unmask: et
+};
+if (!process.env.WS_NO_BUFFER_UTIL)
+  try {
+    const s = require("bufferutil");
+    xt = te.exports.mask = function(e, t, r, i, n) {
+      n < 48 ? Je(e, t, r, i, n) : s.mask(e, t, r, i, n);
+    }, bt = te.exports.unmask = function(e, t) {
+      e.length < 32 ? et(e, t) : s.unmask(e, t);
+    };
+  } catch {
+  }
+var ne = te.exports;
+const Ce = Symbol("kDone"), ue = Symbol("kRun");
+let Ct = class {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(e) {
+    this[Ce] = () => {
+      this.pending--, this[ue]();
+    }, this.concurrency = e || 1 / 0, this.jobs = [], this.pending = 0;
+  }
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(e) {
+    this.jobs.push(e), this[ue]();
+  }
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [ue]() {
+    if (this.pending !== this.concurrency && this.jobs.length) {
+      const e = this.jobs.shift();
+      this.pending++, e(this[Ce]);
+    }
+  }
+};
+var Tt = Ct;
+const W = S, Te = ne, Lt = Tt, { kStatusCode: tt } = U, Nt = Buffer[Symbol.species], Pt = Buffer.from([0, 0, 255, 255]), se = Symbol("permessage-deflate"), w = Symbol("total-length"), V = Symbol("callback"), C = Symbol("buffers"), J = Symbol("error");
+let K, Rt = class {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed if context takeover is disabled
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(e, t, r) {
+    if (this._maxPayload = r | 0, this._options = e || {}, this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024, this._isServer = !!t, this._deflate = null, this._inflate = null, this.params = null, !K) {
+      const i = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
+      K = new Lt(i);
+    }
+  }
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return "permessage-deflate";
+  }
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const e = {};
+    return this._options.serverNoContextTakeover && (e.server_no_context_takeover = !0), this._options.clientNoContextTakeover && (e.client_no_context_takeover = !0), this._options.serverMaxWindowBits && (e.server_max_window_bits = this._options.serverMaxWindowBits), this._options.clientMaxWindowBits ? e.client_max_window_bits = this._options.clientMaxWindowBits : this._options.clientMaxWindowBits == null && (e.client_max_window_bits = !0), e;
+  }
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(e) {
+    return e = this.normalizeParams(e), this.params = this._isServer ? this.acceptAsServer(e) : this.acceptAsClient(e), this.params;
+  }
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate && (this._inflate.close(), this._inflate = null), this._deflate) {
+      const e = this._deflate[V];
+      this._deflate.close(), this._deflate = null, e && e(
+        new Error(
+          "The deflate stream was closed while data was being processed"
+        )
+      );
+    }
+  }
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(e) {
+    const t = this._options, r = e.find((i) => !(t.serverNoContextTakeover === !1 && i.server_no_context_takeover || i.server_max_window_bits && (t.serverMaxWindowBits === !1 || typeof t.serverMaxWindowBits == "number" && t.serverMaxWindowBits > i.server_max_window_bits) || typeof t.clientMaxWindowBits == "number" && !i.client_max_window_bits));
+    if (!r)
+      throw new Error("None of the extension offers can be accepted");
+    return t.serverNoContextTakeover && (r.server_no_context_takeover = !0), t.clientNoContextTakeover && (r.client_no_context_takeover = !0), typeof t.serverMaxWindowBits == "number" && (r.server_max_window_bits = t.serverMaxWindowBits), typeof t.clientMaxWindowBits == "number" ? r.client_max_window_bits = t.clientMaxWindowBits : (r.client_max_window_bits === !0 || t.clientMaxWindowBits === !1) && delete r.client_max_window_bits, r;
+  }
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(e) {
+    const t = e[0];
+    if (this._options.clientNoContextTakeover === !1 && t.client_no_context_takeover)
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    if (!t.client_max_window_bits)
+      typeof this._options.clientMaxWindowBits == "number" && (t.client_max_window_bits = this._options.clientMaxWindowBits);
+    else if (this._options.clientMaxWindowBits === !1 || typeof this._options.clientMaxWindowBits == "number" && t.client_max_window_bits > this._options.clientMaxWindowBits)
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    return t;
+  }
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(e) {
+    return e.forEach((t) => {
+      Object.keys(t).forEach((r) => {
+        let i = t[r];
+        if (i.length > 1)
+          throw new Error(`Parameter "${r}" must have only a single value`);
+        if (i = i[0], r === "client_max_window_bits") {
+          if (i !== !0) {
+            const n = +i;
+            if (!Number.isInteger(n) || n < 8 || n > 15)
+              throw new TypeError(
+                `Invalid value for parameter "${r}": ${i}`
+              );
+            i = n;
+          } else if (!this._isServer)
+            throw new TypeError(
+              `Invalid value for parameter "${r}": ${i}`
+            );
+        } else if (r === "server_max_window_bits") {
+          const n = +i;
+          if (!Number.isInteger(n) || n < 8 || n > 15)
+            throw new TypeError(
+              `Invalid value for parameter "${r}": ${i}`
+            );
+          i = n;
+        } else if (r === "client_no_context_takeover" || r === "server_no_context_takeover") {
+          if (i !== !0)
+            throw new TypeError(
+              `Invalid value for parameter "${r}": ${i}`
+            );
+        } else
+          throw new Error(`Unknown parameter "${r}"`);
+        t[r] = i;
+      });
+    }), e;
+  }
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(e, t, r) {
+    K.add((i) => {
+      this._decompress(e, t, (n, o) => {
+        i(), r(n, o);
+      });
+    });
+  }
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(e, t, r) {
+    K.add((i) => {
+      this._compress(e, t, (n, o) => {
+        i(), r(n, o);
+      });
+    });
+  }
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(e, t, r) {
+    const i = this._isServer ? "client" : "server";
+    if (!this._inflate) {
+      const n = `${i}_max_window_bits`, o = typeof this.params[n] != "number" ? W.Z_DEFAULT_WINDOWBITS : this.params[n];
+      this._inflate = W.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits: o
+      }), this._inflate[se] = this, this._inflate[w] = 0, this._inflate[C] = [], this._inflate.on("error", Bt), this._inflate.on("data", st);
+    }
+    this._inflate[V] = r, this._inflate.write(e), t && this._inflate.write(Pt), this._inflate.flush(() => {
+      const n = this._inflate[J];
+      if (n) {
+        this._inflate.close(), this._inflate = null, r(n);
+        return;
+      }
+      const o = Te.concat(
+        this._inflate[C],
+        this._inflate[w]
+      );
+      this._inflate._readableState.endEmitted ? (this._inflate.close(), this._inflate = null) : (this._inflate[w] = 0, this._inflate[C] = [], t && this.params[`${i}_no_context_takeover`] && this._inflate.reset()), r(null, o);
+    });
+  }
+  /**
+   * Compress data.
+   *
+   * @param {(Buffer|String)} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(e, t, r) {
+    const i = this._isServer ? "server" : "client";
+    if (!this._deflate) {
+      const n = `${i}_max_window_bits`, o = typeof this.params[n] != "number" ? W.Z_DEFAULT_WINDOWBITS : this.params[n];
+      this._deflate = W.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits: o
+      }), this._deflate[w] = 0, this._deflate[C] = [], this._deflate.on("data", Ut);
+    }
+    this._deflate[V] = r, this._deflate.write(e), this._deflate.flush(W.Z_SYNC_FLUSH, () => {
+      if (!this._deflate)
+        return;
+      let n = Te.concat(
+        this._deflate[C],
+        this._deflate[w]
+      );
+      t && (n = new Nt(n.buffer, n.byteOffset, n.length - 4)), this._deflate[V] = null, this._deflate[w] = 0, this._deflate[C] = [], t && this.params[`${i}_no_context_takeover`] && this._deflate.reset(), r(null, n);
+    });
+  }
+};
+var oe = Rt;
+function Ut(s) {
+  this[C].push(s), this[w] += s.length;
+}
+function st(s) {
+  if (this[w] += s.length, this[se]._maxPayload < 1 || this[w] <= this[se]._maxPayload) {
+    this[C].push(s);
+    return;
+  }
+  this[J] = new RangeError("Max payload size exceeded"), this[J].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH", this[J][tt] = 1009, this.removeListener("data", st), this.reset();
+}
+function Bt(s) {
+  this[se]._inflate = null, s[tt] = 1007, this[V](s);
+}
+var re = { exports: {} };
+const $t = {}, Mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: $t
+}, Symbol.toStringTag, { value: "Module" })), It = /* @__PURE__ */ gt(Mt);
+var Le;
+const { isUtf8: Ne } = S, Dt = [
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  // 0 - 15
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  // 16 - 31
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  0,
+  1,
+  1,
+  0,
+  // 32 - 47
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  // 48 - 63
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  // 64 - 79
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  1,
+  // 80 - 95
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  // 96 - 111
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0
+  // 112 - 127
+];
+function Wt(s) {
+  return s >= 1e3 && s <= 1014 && s !== 1004 && s !== 1005 && s !== 1006 || s >= 3e3 && s <= 4999;
+}
+function be(s) {
+  const e = s.length;
+  let t = 0;
+  for (; t < e; )
+    if (!(s[t] & 128))
+      t++;
+    else if ((s[t] & 224) === 192) {
+      if (t + 1 === e || (s[t + 1] & 192) !== 128 || (s[t] & 254) === 192)
+        return !1;
+      t += 2;
+    } else if ((s[t] & 240) === 224) {
+      if (t + 2 >= e || (s[t + 1] & 192) !== 128 || (s[t + 2] & 192) !== 128 || s[t] === 224 && (s[t + 1] & 224) === 128 || // Overlong
+      s[t] === 237 && (s[t + 1] & 224) === 160)
+        return !1;
+      t += 3;
+    } else if ((s[t] & 248) === 240) {
+      if (t + 3 >= e || (s[t + 1] & 192) !== 128 || (s[t + 2] & 192) !== 128 || (s[t + 3] & 192) !== 128 || s[t] === 240 && (s[t + 1] & 240) === 128 || // Overlong
+      s[t] === 244 && s[t + 1] > 143 || s[t] > 244)
+        return !1;
+      t += 4;
+    } else
+      return !1;
+  return !0;
+}
+re.exports = {
+  isValidStatusCode: Wt,
+  isValidUTF8: be,
+  tokenChars: Dt
+};
+if (Ne)
+  Le = re.exports.isValidUTF8 = function(s) {
+    return s.length < 24 ? be(s) : Ne(s);
+  };
+else if (!process.env.WS_NO_UTF_8_VALIDATE)
+  try {
+    const s = It;
+    Le = re.exports.isValidUTF8 = function(e) {
+      return e.length < 32 ? be(e) : s(e);
+    };
+  } catch {
+  }
+var ae = re.exports;
+const { Writable: At } = S, Pe = oe, {
+  BINARY_TYPES: Ft,
+  EMPTY_BUFFER: Re,
+  kStatusCode: jt,
+  kWebSocket: Gt
+} = U, { concat: de, toArrayBuffer: Vt, unmask: Ht } = ne, { isValidStatusCode: zt, isValidUTF8: Ue } = ae, X = Buffer[Symbol.species], A = 0, Be = 1, $e = 2, Me = 3, _e = 4, Yt = 5;
+let qt = class extends At {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {Object} [options] Options object
+   * @param {String} [options.binaryType=nodebuffer] The type for binary data
+   * @param {Object} [options.extensions] An object containing the negotiated
+   *     extensions
+   * @param {Boolean} [options.isServer=false] Specifies whether to operate in
+   *     client or server mode
+   * @param {Number} [options.maxPayload=0] The maximum allowed message length
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   */
+  constructor(e = {}) {
+    super(), this._binaryType = e.binaryType || Ft[0], this._extensions = e.extensions || {}, this._isServer = !!e.isServer, this._maxPayload = e.maxPayload | 0, this._skipUTF8Validation = !!e.skipUTF8Validation, this[Gt] = void 0, this._bufferedBytes = 0, this._buffers = [], this._compressed = !1, this._payloadLength = 0, this._mask = void 0, this._fragmented = 0, this._masked = !1, this._fin = !1, this._opcode = 0, this._totalPayloadLength = 0, this._messageLength = 0, this._fragments = [], this._state = A, this._loop = !1;
+  }
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(e, t, r) {
+    if (this._opcode === 8 && this._state == A)
+      return r();
+    this._bufferedBytes += e.length, this._buffers.push(e), this.startLoop(r);
+  }
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(e) {
+    if (this._bufferedBytes -= e, e === this._buffers[0].length)
+      return this._buffers.shift();
+    if (e < this._buffers[0].length) {
+      const r = this._buffers[0];
+      return this._buffers[0] = new X(
+        r.buffer,
+        r.byteOffset + e,
+        r.length - e
+      ), new X(r.buffer, r.byteOffset, e);
+    }
+    const t = Buffer.allocUnsafe(e);
+    do {
+      const r = this._buffers[0], i = t.length - e;
+      e >= r.length ? t.set(this._buffers.shift(), i) : (t.set(new Uint8Array(r.buffer, r.byteOffset, e), i), this._buffers[0] = new X(
+        r.buffer,
+        r.byteOffset + e,
+        r.length - e
+      )), e -= r.length;
+    } while (e > 0);
+    return t;
+  }
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(e) {
+    let t;
+    this._loop = !0;
+    do
+      switch (this._state) {
+        case A:
+          t = this.getInfo();
+          break;
+        case Be:
+          t = this.getPayloadLength16();
+          break;
+        case $e:
+          t = this.getPayloadLength64();
+          break;
+        case Me:
+          this.getMask();
+          break;
+        case _e:
+          t = this.getData(e);
+          break;
+        default:
+          this._loop = !1;
+          return;
+      }
+    while (this._loop);
+    e(t);
+  }
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getInfo() {
+    if (this._bufferedBytes < 2) {
+      this._loop = !1;
+      return;
+    }
+    const e = this.consume(2);
+    if (e[0] & 48)
+      return this._loop = !1, g(
+        RangeError,
+        "RSV2 and RSV3 must be clear",
+        !0,
+        1002,
+        "WS_ERR_UNEXPECTED_RSV_2_3"
+      );
+    const t = (e[0] & 64) === 64;
+    if (t && !this._extensions[Pe.extensionName])
+      return this._loop = !1, g(
+        RangeError,
+        "RSV1 must be clear",
+        !0,
+        1002,
+        "WS_ERR_UNEXPECTED_RSV_1"
+      );
+    if (this._fin = (e[0] & 128) === 128, this._opcode = e[0] & 15, this._payloadLength = e[1] & 127, this._opcode === 0) {
+      if (t)
+        return this._loop = !1, g(
+          RangeError,
+          "RSV1 must be clear",
+          !0,
+          1002,
+          "WS_ERR_UNEXPECTED_RSV_1"
+        );
+      if (!this._fragmented)
+        return this._loop = !1, g(
+          RangeError,
+          "invalid opcode 0",
+          !0,
+          1002,
+          "WS_ERR_INVALID_OPCODE"
+        );
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 1 || this._opcode === 2) {
+      if (this._fragmented)
+        return this._loop = !1, g(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          !0,
+          1002,
+          "WS_ERR_INVALID_OPCODE"
+        );
+      this._compressed = t;
+    } else if (this._opcode > 7 && this._opcode < 11) {
+      if (!this._fin)
+        return this._loop = !1, g(
+          RangeError,
+          "FIN must be set",
+          !0,
+          1002,
+          "WS_ERR_EXPECTED_FIN"
+        );
+      if (t)
+        return this._loop = !1, g(
+          RangeError,
+          "RSV1 must be clear",
+          !0,
+          1002,
+          "WS_ERR_UNEXPECTED_RSV_1"
+        );
+      if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1)
+        return this._loop = !1, g(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          !0,
+          1002,
+          "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+        );
+    } else
+      return this._loop = !1, g(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        !0,
+        1002,
+        "WS_ERR_INVALID_OPCODE"
+      );
+    if (!this._fin && !this._fragmented && (this._fragmented = this._opcode), this._masked = (e[1] & 128) === 128, this._isServer) {
+      if (!this._masked)
+        return this._loop = !1, g(
+          RangeError,
+          "MASK must be set",
+          !0,
+          1002,
+          "WS_ERR_EXPECTED_MASK"
+        );
+    } else if (this._masked)
+      return this._loop = !1, g(
+        RangeError,
+        "MASK must be clear",
+        !0,
+        1002,
+        "WS_ERR_UNEXPECTED_MASK"
+      );
+    if (this._payloadLength === 126)
+      this._state = Be;
+    else if (this._payloadLength === 127)
+      this._state = $e;
+    else
+      return this.haveLength();
+  }
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength16() {
+    if (this._bufferedBytes < 2) {
+      this._loop = !1;
+      return;
+    }
+    return this._payloadLength = this.consume(2).readUInt16BE(0), this.haveLength();
+  }
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength64() {
+    if (this._bufferedBytes < 8) {
+      this._loop = !1;
+      return;
+    }
+    const e = this.consume(8), t = e.readUInt32BE(0);
+    return t > Math.pow(2, 21) - 1 ? (this._loop = !1, g(
+      RangeError,
+      "Unsupported WebSocket frame: payload length > 2^53 - 1",
+      !1,
+      1009,
+      "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
+    )) : (this._payloadLength = t * Math.pow(2, 32) + e.readUInt32BE(4), this.haveLength());
+  }
+  /**
+   * Payload length has been read.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  haveLength() {
+    if (this._payloadLength && this._opcode < 8 && (this._totalPayloadLength += this._payloadLength, this._totalPayloadLength > this._maxPayload && this._maxPayload > 0))
+      return this._loop = !1, g(
+        RangeError,
+        "Max payload size exceeded",
+        !1,
+        1009,
+        "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+      );
+    this._masked ? this._state = Me : this._state = _e;
+  }
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = !1;
+      return;
+    }
+    this._mask = this.consume(4), this._state = _e;
+  }
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  getData(e) {
+    let t = Re;
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = !1;
+        return;
+      }
+      t = this.consume(this._payloadLength), this._masked && this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3] && Ht(t, this._mask);
+    }
+    if (this._opcode > 7)
+      return this.controlMessage(t);
+    if (this._compressed) {
+      this._state = Yt, this.decompress(t, e);
+      return;
+    }
+    return t.length && (this._messageLength = this._totalPayloadLength, this._fragments.push(t)), this.dataMessage();
+  }
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(e, t) {
+    this._extensions[Pe.extensionName].decompress(e, this._fin, (i, n) => {
+      if (i)
+        return t(i);
+      if (n.length) {
+        if (this._messageLength += n.length, this._messageLength > this._maxPayload && this._maxPayload > 0)
+          return t(
+            g(
+              RangeError,
+              "Max payload size exceeded",
+              !1,
+              1009,
+              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+            )
+          );
+        this._fragments.push(n);
+      }
+      const o = this.dataMessage();
+      if (o)
+        return t(o);
+      this.startLoop(t);
+    });
+  }
+  /**
+   * Handles a data message.
+   *
+   * @return {(Error|undefined)} A possible error
+   * @private
+   */
+  dataMessage() {
+    if (this._fin) {
+      const e = this._messageLength, t = this._fragments;
+      if (this._totalPayloadLength = 0, this._messageLength = 0, this._fragmented = 0, this._fragments = [], this._opcode === 2) {
+        let r;
+        this._binaryType === "nodebuffer" ? r = de(t, e) : this._binaryType === "arraybuffer" ? r = Vt(de(t, e)) : r = t, this.emit("message", r, !0);
+      } else {
+        const r = de(t, e);
+        if (!this._skipUTF8Validation && !Ue(r))
+          return this._loop = !1, g(
+            Error,
+            "invalid UTF-8 sequence",
+            !0,
+            1007,
+            "WS_ERR_INVALID_UTF8"
+          );
+        this.emit("message", r, !1);
+      }
+    }
+    this._state = A;
+  }
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(e) {
+    if (this._opcode === 8)
+      if (this._loop = !1, e.length === 0)
+        this.emit("conclude", 1005, Re), this.end();
+      else {
+        const t = e.readUInt16BE(0);
+        if (!zt(t))
+          return g(
+            RangeError,
+            `invalid status code ${t}`,
+            !0,
+            1002,
+            "WS_ERR_INVALID_CLOSE_CODE"
+          );
+        const r = new X(
+          e.buffer,
+          e.byteOffset + 2,
+          e.length - 2
+        );
+        if (!this._skipUTF8Validation && !Ue(r))
+          return g(
+            Error,
+            "invalid UTF-8 sequence",
+            !0,
+            1007,
+            "WS_ERR_INVALID_UTF8"
+          );
+        this.emit("conclude", t, r), this.end();
+      }
+    else
+      this._opcode === 9 ? this.emit("ping", e) : this.emit("pong", e);
+    this._state = A;
+  }
+};
+var rt = qt;
+function g(s, e, t, r, i) {
+  const n = new s(
+    t ? `Invalid WebSocket frame: ${e}` : e
+  );
+  return Error.captureStackTrace(n, g), n.code = i, n[jt] = r, n;
+}
+const qs = /* @__PURE__ */ z(rt), { randomFillSync: Kt } = S, Ie = oe, { EMPTY_BUFFER: Xt } = U, { isValidStatusCode: Zt } = ae, { mask: De, toBuffer: M } = ne, x = Symbol("kByteLength"), Qt = Buffer.alloc(4);
+let Jt = class P {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {(net.Socket|tls.Socket)} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   * @param {Function} [generateMask] The function used to generate the masking
+   *     key
+   */
+  constructor(e, t, r) {
+    this._extensions = t || {}, r && (this._generateMask = r, this._maskBuffer = Buffer.alloc(4)), this._socket = e, this._firstFragment = !0, this._compress = !1, this._bufferedBytes = 0, this._deflating = !1, this._queue = [];
+  }
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {(Buffer|String)} data The data to frame
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {(Buffer|String)[]} The framed data
+   * @public
+   */
+  static frame(e, t) {
+    let r, i = !1, n = 2, o = !1;
+    t.mask && (r = t.maskBuffer || Qt, t.generateMask ? t.generateMask(r) : Kt(r, 0, 4), o = (r[0] | r[1] | r[2] | r[3]) === 0, n = 6);
+    let l;
+    typeof e == "string" ? (!t.mask || o) && t[x] !== void 0 ? l = t[x] : (e = Buffer.from(e), l = e.length) : (l = e.length, i = t.mask && t.readOnly && !o);
+    let f = l;
+    l >= 65536 ? (n += 8, f = 127) : l > 125 && (n += 2, f = 126);
+    const a = Buffer.allocUnsafe(i ? l + n : n);
+    return a[0] = t.fin ? t.opcode | 128 : t.opcode, t.rsv1 && (a[0] |= 64), a[1] = f, f === 126 ? a.writeUInt16BE(l, 2) : f === 127 && (a[2] = a[3] = 0, a.writeUIntBE(l, 4, 6)), t.mask ? (a[1] |= 128, a[n - 4] = r[0], a[n - 3] = r[1], a[n - 2] = r[2], a[n - 1] = r[3], o ? [a, e] : i ? (De(e, r, a, n, l), [a]) : (De(e, r, e, 0, l), [a, e])) : [a, e];
+  }
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {(String|Buffer)} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(e, t, r, i) {
+    let n;
+    if (e === void 0)
+      n = Xt;
+    else {
+      if (typeof e != "number" || !Zt(e))
+        throw new TypeError("First argument must be a valid error code number");
+      if (t === void 0 || !t.length)
+        n = Buffer.allocUnsafe(2), n.writeUInt16BE(e, 0);
+      else {
+        const l = Buffer.byteLength(t);
+        if (l > 123)
+          throw new RangeError("The message must not be greater than 123 bytes");
+        n = Buffer.allocUnsafe(2 + l), n.writeUInt16BE(e, 0), typeof t == "string" ? n.write(t, 2) : n.set(t, 2);
+      }
+    }
+    const o = {
+      [x]: n.length,
+      fin: !0,
+      generateMask: this._generateMask,
+      mask: r,
+      maskBuffer: this._maskBuffer,
+      opcode: 8,
+      readOnly: !1,
+      rsv1: !1
+    };
+    this._deflating ? this.enqueue([this.dispatch, n, !1, o, i]) : this.sendFrame(P.frame(n, o), i);
+  }
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(e, t, r) {
+    let i, n;
+    if (typeof e == "string" ? (i = Buffer.byteLength(e), n = !1) : (e = M(e), i = e.length, n = M.readOnly), i > 125)
+      throw new RangeError("The data size must not be greater than 125 bytes");
+    const o = {
+      [x]: i,
+      fin: !0,
+      generateMask: this._generateMask,
+      mask: t,
+      maskBuffer: this._maskBuffer,
+      opcode: 9,
+      readOnly: n,
+      rsv1: !1
+    };
+    this._deflating ? this.enqueue([this.dispatch, e, !1, o, r]) : this.sendFrame(P.frame(e, o), r);
+  }
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(e, t, r) {
+    let i, n;
+    if (typeof e == "string" ? (i = Buffer.byteLength(e), n = !1) : (e = M(e), i = e.length, n = M.readOnly), i > 125)
+      throw new RangeError("The data size must not be greater than 125 bytes");
+    const o = {
+      [x]: i,
+      fin: !0,
+      generateMask: this._generateMask,
+      mask: t,
+      maskBuffer: this._maskBuffer,
+      opcode: 10,
+      readOnly: n,
+      rsv1: !1
+    };
+    this._deflating ? this.enqueue([this.dispatch, e, !1, o, r]) : this.sendFrame(P.frame(e, o), r);
+  }
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(e, t, r) {
+    const i = this._extensions[Ie.extensionName];
+    let n = t.binary ? 2 : 1, o = t.compress, l, f;
+    if (typeof e == "string" ? (l = Buffer.byteLength(e), f = !1) : (e = M(e), l = e.length, f = M.readOnly), this._firstFragment ? (this._firstFragment = !1, o && i && i.params[i._isServer ? "server_no_context_takeover" : "client_no_context_takeover"] && (o = l >= i._threshold), this._compress = o) : (o = !1, n = 0), t.fin && (this._firstFragment = !0), i) {
+      const a = {
+        [x]: l,
+        fin: t.fin,
+        generateMask: this._generateMask,
+        mask: t.mask,
+        maskBuffer: this._maskBuffer,
+        opcode: n,
+        readOnly: f,
+        rsv1: o
+      };
+      this._deflating ? this.enqueue([this.dispatch, e, this._compress, a, r]) : this.dispatch(e, this._compress, a, r);
+    } else
+      this.sendFrame(
+        P.frame(e, {
+          [x]: l,
+          fin: t.fin,
+          generateMask: this._generateMask,
+          mask: t.mask,
+          maskBuffer: this._maskBuffer,
+          opcode: n,
+          readOnly: f,
+          rsv1: !1
+        }),
+        r
+      );
+  }
+  /**
+   * Dispatches a message.
+   *
+   * @param {(Buffer|String)} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
+   *     key
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(e, t, r, i) {
+    if (!t) {
+      this.sendFrame(P.frame(e, r), i);
+      return;
+    }
+    const n = this._extensions[Ie.extensionName];
+    this._bufferedBytes += r[x], this._deflating = !0, n.compress(e, r.fin, (o, l) => {
+      if (this._socket.destroyed) {
+        const f = new Error(
+          "The socket was closed while data was being compressed"
+        );
+        typeof i == "function" && i(f);
+        for (let a = 0; a < this._queue.length; a++) {
+          const c = this._queue[a], h = c[c.length - 1];
+          typeof h == "function" && h(f);
+        }
+        return;
+      }
+      this._bufferedBytes -= r[x], this._deflating = !1, r.readOnly = !1, this.sendFrame(P.frame(l, r), i), this.dequeue();
+    });
+  }
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    for (; !this._deflating && this._queue.length; ) {
+      const e = this._queue.shift();
+      this._bufferedBytes -= e[3][x], Reflect.apply(e[0], this, e.slice(1));
+    }
+  }
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(e) {
+    this._bufferedBytes += e[3][x], this._queue.push(e);
+  }
+  /**
+   * Sends a frame.
+   *
+   * @param {Buffer[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(e, t) {
+    e.length === 2 ? (this._socket.cork(), this._socket.write(e[0]), this._socket.write(e[1], t), this._socket.uncork()) : this._socket.write(e[0], t);
+  }
+};
+var it = Jt;
+const Ks = /* @__PURE__ */ z(it), { kForOnEventAttribute: F, kListener: pe } = U, We = Symbol("kCode"), Ae = Symbol("kData"), Fe = Symbol("kError"), je = Symbol("kMessage"), Ge = Symbol("kReason"), I = Symbol("kTarget"), Ve = Symbol("kType"), He = Symbol("kWasClean");
+class B {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @throws {TypeError} If the `type` argument is not specified
+   */
+  constructor(e) {
+    this[I] = null, this[Ve] = e;
+  }
+  /**
+   * @type {*}
+   */
+  get target() {
+    return this[I];
+  }
+  /**
+   * @type {String}
+   */
+  get type() {
+    return this[Ve];
+  }
+}
+Object.defineProperty(B.prototype, "target", { enumerable: !0 });
+Object.defineProperty(B.prototype, "type", { enumerable: !0 });
+class Y extends B {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {Number} [options.code=0] The status code explaining why the
+   *     connection was closed
+   * @param {String} [options.reason=''] A human-readable string explaining why
+   *     the connection was closed
+   * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+   *     connection was cleanly closed
+   */
+  constructor(e, t = {}) {
+    super(e), this[We] = t.code === void 0 ? 0 : t.code, this[Ge] = t.reason === void 0 ? "" : t.reason, this[He] = t.wasClean === void 0 ? !1 : t.wasClean;
+  }
+  /**
+   * @type {Number}
+   */
+  get code() {
+    return this[We];
+  }
+  /**
+   * @type {String}
+   */
+  get reason() {
+    return this[Ge];
+  }
+  /**
+   * @type {Boolean}
+   */
+  get wasClean() {
+    return this[He];
+  }
+}
+Object.defineProperty(Y.prototype, "code", { enumerable: !0 });
+Object.defineProperty(Y.prototype, "reason", { enumerable: !0 });
+Object.defineProperty(Y.prototype, "wasClean", { enumerable: !0 });
+class le extends B {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.error=null] The error that generated this event
+   * @param {String} [options.message=''] The error message
+   */
+  constructor(e, t = {}) {
+    super(e), this[Fe] = t.error === void 0 ? null : t.error, this[je] = t.message === void 0 ? "" : t.message;
+  }
+  /**
+   * @type {*}
+   */
+  get error() {
+    return this[Fe];
+  }
+  /**
+   * @type {String}
+   */
+  get message() {
+    return this[je];
+  }
+}
+Object.defineProperty(le.prototype, "error", { enumerable: !0 });
+Object.defineProperty(le.prototype, "message", { enumerable: !0 });
+class xe extends B {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} [options] A dictionary object that allows for setting
+   *     attributes via object members of the same name
+   * @param {*} [options.data=null] The message content
+   */
+  constructor(e, t = {}) {
+    super(e), this[Ae] = t.data === void 0 ? null : t.data;
+  }
+  /**
+   * @type {*}
+   */
+  get data() {
+    return this[Ae];
+  }
+}
+Object.defineProperty(xe.prototype, "data", { enumerable: !0 });
+const es = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {(Function|Object)} handler The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(s, e, t = {}) {
+    for (const i of this.listeners(s))
+      if (!t[F] && i[pe] === e && !i[F])
+        return;
+    let r;
+    if (s === "message")
+      r = function(n, o) {
+        const l = new xe("message", {
+          data: o ? n : n.toString()
+        });
+        l[I] = this, Z(e, this, l);
+      };
+    else if (s === "close")
+      r = function(n, o) {
+        const l = new Y("close", {
+          code: n,
+          reason: o.toString(),
+          wasClean: this._closeFrameReceived && this._closeFrameSent
+        });
+        l[I] = this, Z(e, this, l);
+      };
+    else if (s === "error")
+      r = function(n) {
+        const o = new le("error", {
+          error: n,
+          message: n.message
+        });
+        o[I] = this, Z(e, this, o);
+      };
+    else if (s === "open")
+      r = function() {
+        const n = new B("open");
+        n[I] = this, Z(e, this, n);
+      };
+    else
+      return;
+    r[F] = !!t[F], r[pe] = e, t.once ? this.once(s, r) : this.on(s, r);
+  },
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {(Function|Object)} handler The listener to remove
+   * @public
+   */
+  removeEventListener(s, e) {
+    for (const t of this.listeners(s))
+      if (t[pe] === e && !t[F]) {
+        this.removeListener(s, t);
+        break;
+      }
+  }
+};
+var ts = {
+  CloseEvent: Y,
+  ErrorEvent: le,
+  Event: B,
+  EventTarget: es,
+  MessageEvent: xe
+};
+function Z(s, e, t) {
+  typeof s == "object" && s.handleEvent ? s.handleEvent.call(s, t) : s.call(e, t);
+}
+const { tokenChars: j } = ae;
+function k(s, e, t) {
+  s[e] === void 0 ? s[e] = [t] : s[e].push(t);
+}
+function ss(s) {
+  const e = /* @__PURE__ */ Object.create(null);
+  let t = /* @__PURE__ */ Object.create(null), r = !1, i = !1, n = !1, o, l, f = -1, a = -1, c = -1, h = 0;
+  for (; h < s.length; h++)
+    if (a = s.charCodeAt(h), o === void 0)
+      if (c === -1 && j[a] === 1)
+        f === -1 && (f = h);
+      else if (h !== 0 && (a === 32 || a === 9))
+        c === -1 && f !== -1 && (c = h);
+      else if (a === 59 || a === 44) {
+        if (f === -1)
+          throw new SyntaxError(`Unexpected character at index ${h}`);
+        c === -1 && (c = h);
+        const v = s.slice(f, c);
+        a === 44 ? (k(e, v, t), t = /* @__PURE__ */ Object.create(null)) : o = v, f = c = -1;
+      } else
+        throw new SyntaxError(`Unexpected character at index ${h}`);
+    else if (l === void 0)
+      if (c === -1 && j[a] === 1)
+        f === -1 && (f = h);
+      else if (a === 32 || a === 9)
+        c === -1 && f !== -1 && (c = h);
+      else if (a === 59 || a === 44) {
+        if (f === -1)
+          throw new SyntaxError(`Unexpected character at index ${h}`);
+        c === -1 && (c = h), k(t, s.slice(f, c), !0), a === 44 && (k(e, o, t), t = /* @__PURE__ */ Object.create(null), o = void 0), f = c = -1;
+      } else if (a === 61 && f !== -1 && c === -1)
+        l = s.slice(f, h), f = c = -1;
+      else
+        throw new SyntaxError(`Unexpected character at index ${h}`);
+    else if (i) {
+      if (j[a] !== 1)
+        throw new SyntaxError(`Unexpected character at index ${h}`);
+      f === -1 ? f = h : r || (r = !0), i = !1;
+    } else if (n)
+      if (j[a] === 1)
+        f === -1 && (f = h);
+      else if (a === 34 && f !== -1)
+        n = !1, c = h;
+      else if (a === 92)
+        i = !0;
+      else
+        throw new SyntaxError(`Unexpected character at index ${h}`);
+    else if (a === 34 && s.charCodeAt(h - 1) === 61)
+      n = !0;
+    else if (c === -1 && j[a] === 1)
+      f === -1 && (f = h);
+    else if (f !== -1 && (a === 32 || a === 9))
+      c === -1 && (c = h);
+    else if (a === 59 || a === 44) {
+      if (f === -1)
+        throw new SyntaxError(`Unexpected character at index ${h}`);
+      c === -1 && (c = h);
+      let v = s.slice(f, c);
+      r && (v = v.replace(/\\/g, ""), r = !1), k(t, l, v), a === 44 && (k(e, o, t), t = /* @__PURE__ */ Object.create(null), o = void 0), l = void 0, f = c = -1;
+    } else
+      throw new SyntaxError(`Unexpected character at index ${h}`);
+  if (f === -1 || n || a === 32 || a === 9)
+    throw new SyntaxError("Unexpected end of input");
+  c === -1 && (c = h);
+  const p = s.slice(f, c);
+  return o === void 0 ? k(e, p, t) : (l === void 0 ? k(t, p, !0) : r ? k(t, l, p.replace(/\\/g, "")) : k(t, l, p), k(e, o, t)), e;
+}
+function rs(s) {
+  return Object.keys(s).map((e) => {
+    let t = s[e];
+    return Array.isArray(t) || (t = [t]), t.map((r) => [e].concat(
+      Object.keys(r).map((i) => {
+        let n = r[i];
+        return Array.isArray(n) || (n = [n]), n.map((o) => o === !0 ? i : `${i}=${o}`).join("; ");
+      })
+    ).join("; ")).join(", ");
+  }).join(", ");
+}
+var nt = { format: rs, parse: ss };
+const is = S, ns = S, os = S, ot = S, as = S, { randomBytes: ls, createHash: fs } = S, { URL: me } = S, T = oe, hs = rt, cs = it, {
+  BINARY_TYPES: ze,
+  EMPTY_BUFFER: Q,
+  GUID: us,
+  kForOnEventAttribute: ge,
+  kListener: ds,
+  kStatusCode: _s,
+  kWebSocket: y,
+  NOOP: at
+} = U, {
+  EventTarget: { addEventListener: ps, removeEventListener: ms }
+} = ts, { format: gs, parse: ys } = nt, { toBuffer: vs } = ne, Ss = 30 * 1e3, lt = Symbol("kAborted"), ye = [8, 13], O = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"], Es = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+let m = class d extends is {
+  /**
+   * Create a new `WebSocket`.
+   *
+   * @param {(String|URL)} address The URL to which to connect
+   * @param {(String|String[])} [protocols] The subprotocols
+   * @param {Object} [options] Connection options
+   */
+  constructor(e, t, r) {
+    super(), this._binaryType = ze[0], this._closeCode = 1006, this._closeFrameReceived = !1, this._closeFrameSent = !1, this._closeMessage = Q, this._closeTimer = null, this._extensions = {}, this._paused = !1, this._protocol = "", this._readyState = d.CONNECTING, this._receiver = null, this._sender = null, this._socket = null, e !== null ? (this._bufferedAmount = 0, this._isServer = !1, this._redirects = 0, t === void 0 ? t = [] : Array.isArray(t) || (typeof t == "object" && t !== null ? (r = t, t = []) : t = [t]), ht(this, e, t, r)) : this._isServer = !0;
+  }
+  /**
+   * This deviates from the WHATWG interface since ws doesn't support the
+   * required default "blob" type (instead we define a custom "nodebuffer"
+   * type).
+   *
+   * @type {String}
+   */
+  get binaryType() {
+    return this._binaryType;
+  }
+  set binaryType(e) {
+    ze.includes(e) && (this._binaryType = e, this._receiver && (this._receiver._binaryType = e));
+  }
+  /**
+   * @type {Number}
+   */
+  get bufferedAmount() {
+    return this._socket ? this._socket._writableState.length + this._sender._bufferedBytes : this._bufferedAmount;
+  }
+  /**
+   * @type {String}
+   */
+  get extensions() {
+    return Object.keys(this._extensions).join();
+  }
+  /**
+   * @type {Boolean}
+   */
+  get isPaused() {
+    return this._paused;
+  }
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onclose() {
+    return null;
+  }
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onerror() {
+    return null;
+  }
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onopen() {
+    return null;
+  }
+  /**
+   * @type {Function}
+   */
+  /* istanbul ignore next */
+  get onmessage() {
+    return null;
+  }
+  /**
+   * @type {String}
+   */
+  get protocol() {
+    return this._protocol;
+  }
+  /**
+   * @type {Number}
+   */
+  get readyState() {
+    return this._readyState;
+  }
+  /**
+   * @type {String}
+   */
+  get url() {
+    return this._url;
+  }
+  /**
+   * Set up the socket and the internal resources.
+   *
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Object} options Options object
+   * @param {Function} [options.generateMask] The function used to generate the
+   *     masking key
+   * @param {Number} [options.maxPayload=0] The maximum allowed message size
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @private
+   */
+  setSocket(e, t, r) {
+    const i = new hs({
+      binaryType: this.binaryType,
+      extensions: this._extensions,
+      isServer: this._isServer,
+      maxPayload: r.maxPayload,
+      skipUTF8Validation: r.skipUTF8Validation
+    });
+    this._sender = new cs(e, this._extensions, r.generateMask), this._receiver = i, this._socket = e, i[y] = this, e[y] = this, i.on("conclude", ks), i.on("drain", ws), i.on("error", Os), i.on("message", Cs), i.on("ping", Ts), i.on("pong", Ls), e.setTimeout(0), e.setNoDelay(), t.length > 0 && e.unshift(t), e.on("close", ut), e.on("data", fe), e.on("end", dt), e.on("error", _t), this._readyState = d.OPEN, this.emit("open");
+  }
+  /**
+   * Emit the `'close'` event.
+   *
+   * @private
+   */
+  emitClose() {
+    if (!this._socket) {
+      this._readyState = d.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
+      return;
+    }
+    this._extensions[T.extensionName] && this._extensions[T.extensionName].cleanup(), this._receiver.removeAllListeners(), this._readyState = d.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
+  }
+  /**
+   * Start a closing handshake.
+   *
+   *          +----------+   +-----------+   +----------+
+   *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
+   *    |     +----------+   +-----------+   +----------+     |
+   *          +----------+   +-----------+         |
+   * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
+   *          +----------+   +-----------+   |
+   *    |           |                        |   +---+        |
+   *                +------------------------+-->|fin| - - - -
+   *    |         +---+                      |   +---+
+   *     - - - - -|fin|<---------------------+
+   *              +---+
+   *
+   * @param {Number} [code] Status code explaining why the connection is closing
+   * @param {(String|Buffer)} [data] The reason why the connection is
+   *     closing
+   * @public
+   */
+  close(e, t) {
+    if (this.readyState !== d.CLOSED) {
+      if (this.readyState === d.CONNECTING) {
+        b(this, this._req, "WebSocket was closed before the connection was established");
+        return;
+      }
+      if (this.readyState === d.CLOSING) {
+        this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end();
+        return;
+      }
+      this._readyState = d.CLOSING, this._sender.close(e, t, !this._isServer, (r) => {
+        r || (this._closeFrameSent = !0, (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end());
+      }), this._closeTimer = setTimeout(
+        this._socket.destroy.bind(this._socket),
+        Ss
+      );
+    }
+  }
+  /**
+   * Pause the socket.
+   *
+   * @public
+   */
+  pause() {
+    this.readyState === d.CONNECTING || this.readyState === d.CLOSED || (this._paused = !0, this._socket.pause());
+  }
+  /**
+   * Send a ping.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the ping is sent
+   * @public
+   */
+  ping(e, t, r) {
+    if (this.readyState === d.CONNECTING)
+      throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+    if (typeof e == "function" ? (r = e, e = t = void 0) : typeof t == "function" && (r = t, t = void 0), typeof e == "number" && (e = e.toString()), this.readyState !== d.OPEN) {
+      ve(this, e, r);
+      return;
+    }
+    t === void 0 && (t = !this._isServer), this._sender.ping(e || Q, t, r);
+  }
+  /**
+   * Send a pong.
+   *
+   * @param {*} [data] The data to send
+   * @param {Boolean} [mask] Indicates whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when the pong is sent
+   * @public
+   */
+  pong(e, t, r) {
+    if (this.readyState === d.CONNECTING)
+      throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+    if (typeof e == "function" ? (r = e, e = t = void 0) : typeof t == "function" && (r = t, t = void 0), typeof e == "number" && (e = e.toString()), this.readyState !== d.OPEN) {
+      ve(this, e, r);
+      return;
+    }
+    t === void 0 && (t = !this._isServer), this._sender.pong(e || Q, t, r);
+  }
+  /**
+   * Resume the socket.
+   *
+   * @public
+   */
+  resume() {
+    this.readyState === d.CONNECTING || this.readyState === d.CLOSED || (this._paused = !1, this._receiver._writableState.needDrain || this._socket.resume());
+  }
+  /**
+   * Send a data message.
+   *
+   * @param {*} data The message to send
+   * @param {Object} [options] Options object
+   * @param {Boolean} [options.binary] Specifies whether `data` is binary or
+   *     text
+   * @param {Boolean} [options.compress] Specifies whether or not to compress
+   *     `data`
+   * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback which is executed when data is written out
+   * @public
+   */
+  send(e, t, r) {
+    if (this.readyState === d.CONNECTING)
+      throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+    if (typeof t == "function" && (r = t, t = {}), typeof e == "number" && (e = e.toString()), this.readyState !== d.OPEN) {
+      ve(this, e, r);
+      return;
+    }
+    const i = {
+      binary: typeof e != "string",
+      mask: !this._isServer,
+      compress: !0,
+      fin: !0,
+      ...t
+    };
+    this._extensions[T.extensionName] || (i.compress = !1), this._sender.send(e || Q, i, r);
+  }
+  /**
+   * Forcibly close the connection.
+   *
+   * @public
+   */
+  terminate() {
+    if (this.readyState !== d.CLOSED) {
+      if (this.readyState === d.CONNECTING) {
+        b(this, this._req, "WebSocket was closed before the connection was established");
+        return;
+      }
+      this._socket && (this._readyState = d.CLOSING, this._socket.destroy());
+    }
+  }
+};
+Object.defineProperty(m, "CONNECTING", {
+  enumerable: !0,
+  value: O.indexOf("CONNECTING")
+});
+Object.defineProperty(m.prototype, "CONNECTING", {
+  enumerable: !0,
+  value: O.indexOf("CONNECTING")
+});
+Object.defineProperty(m, "OPEN", {
+  enumerable: !0,
+  value: O.indexOf("OPEN")
+});
+Object.defineProperty(m.prototype, "OPEN", {
+  enumerable: !0,
+  value: O.indexOf("OPEN")
+});
+Object.defineProperty(m, "CLOSING", {
+  enumerable: !0,
+  value: O.indexOf("CLOSING")
+});
+Object.defineProperty(m.prototype, "CLOSING", {
+  enumerable: !0,
+  value: O.indexOf("CLOSING")
+});
+Object.defineProperty(m, "CLOSED", {
+  enumerable: !0,
+  value: O.indexOf("CLOSED")
+});
+Object.defineProperty(m.prototype, "CLOSED", {
+  enumerable: !0,
+  value: O.indexOf("CLOSED")
+});
+[
+  "binaryType",
+  "bufferedAmount",
+  "extensions",
+  "isPaused",
+  "protocol",
+  "readyState",
+  "url"
+].forEach((s) => {
+  Object.defineProperty(m.prototype, s, { enumerable: !0 });
+});
+["open", "error", "close", "message"].forEach((s) => {
+  Object.defineProperty(m.prototype, `on${s}`, {
+    enumerable: !0,
+    get() {
+      for (const e of this.listeners(s))
+        if (e[ge])
+          return e[ds];
+      return null;
+    },
+    set(e) {
+      for (const t of this.listeners(s))
+        if (t[ge]) {
+          this.removeListener(s, t);
+          break;
+        }
+      typeof e == "function" && this.addEventListener(s, e, {
+        [ge]: !0
+      });
+    }
+  });
+});
+m.prototype.addEventListener = ps;
+m.prototype.removeEventListener = ms;
+var ft = m;
+function ht(s, e, t, r) {
+  const i = {
+    protocolVersion: ye[1],
+    maxPayload: 104857600,
+    skipUTF8Validation: !1,
+    perMessageDeflate: !0,
+    followRedirects: !1,
+    maxRedirects: 10,
+    ...r,
+    createConnection: void 0,
+    socketPath: void 0,
+    hostname: void 0,
+    protocol: void 0,
+    timeout: void 0,
+    method: "GET",
+    host: void 0,
+    path: void 0,
+    port: void 0
+  };
+  if (!ye.includes(i.protocolVersion))
+    throw new RangeError(
+      `Unsupported protocol version: ${i.protocolVersion} (supported versions: ${ye.join(", ")})`
+    );
+  let n;
+  if (e instanceof me)
+    n = e, s._url = e.href;
+  else {
+    try {
+      n = new me(e);
+    } catch {
+      throw new SyntaxError(`Invalid URL: ${e}`);
+    }
+    s._url = e;
+  }
+  const o = n.protocol === "wss:", l = n.protocol === "ws+unix:";
+  let f;
+  if (n.protocol !== "ws:" && !o && !l ? f = `The URL's protocol must be one of "ws:", "wss:", or "ws+unix:"` : l && !n.pathname ? f = "The URL's pathname is empty" : n.hash && (f = "The URL contains a fragment identifier"), f) {
+    const u = new SyntaxError(f);
+    if (s._redirects === 0)
+      throw u;
+    ee(s, u);
+    return;
+  }
+  const a = o ? 443 : 80, c = ls(16).toString("base64"), h = o ? ns.request : os.request, p = /* @__PURE__ */ new Set();
+  let v;
+  if (i.createConnection = o ? xs : bs, i.defaultPort = i.defaultPort || a, i.port = n.port || a, i.host = n.hostname.startsWith("[") ? n.hostname.slice(1, -1) : n.hostname, i.headers = {
+    ...i.headers,
+    "Sec-WebSocket-Version": i.protocolVersion,
+    "Sec-WebSocket-Key": c,
+    Connection: "Upgrade",
+    Upgrade: "websocket"
+  }, i.path = n.pathname + n.search, i.timeout = i.handshakeTimeout, i.perMessageDeflate && (v = new T(
+    i.perMessageDeflate !== !0 ? i.perMessageDeflate : {},
+    !1,
+    i.maxPayload
+  ), i.headers["Sec-WebSocket-Extensions"] = gs({
+    [T.extensionName]: v.offer()
+  })), t.length) {
+    for (const u of t) {
+      if (typeof u != "string" || !Es.test(u) || p.has(u))
+        throw new SyntaxError(
+          "An invalid or duplicated subprotocol was specified"
+        );
+      p.add(u);
+    }
+    i.headers["Sec-WebSocket-Protocol"] = t.join(",");
+  }
+  if (i.origin && (i.protocolVersion < 13 ? i.headers["Sec-WebSocket-Origin"] = i.origin : i.headers.Origin = i.origin), (n.username || n.password) && (i.auth = `${n.username}:${n.password}`), l) {
+    const u = i.path.split(":");
+    i.socketPath = u[0], i.path = u[1];
+  }
+  let _;
+  if (i.followRedirects) {
+    if (s._redirects === 0) {
+      s._originalIpc = l, s._originalSecure = o, s._originalHostOrSocketPath = l ? i.socketPath : n.host;
+      const u = r && r.headers;
+      if (r = { ...r, headers: {} }, u)
+        for (const [E, $] of Object.entries(u))
+          r.headers[E.toLowerCase()] = $;
+    } else if (s.listenerCount("redirect") === 0) {
+      const u = l ? s._originalIpc ? i.socketPath === s._originalHostOrSocketPath : !1 : s._originalIpc ? !1 : n.host === s._originalHostOrSocketPath;
+      (!u || s._originalSecure && !o) && (delete i.headers.authorization, delete i.headers.cookie, u || delete i.headers.host, i.auth = void 0);
+    }
+    i.auth && !r.headers.authorization && (r.headers.authorization = "Basic " + Buffer.from(i.auth).toString("base64")), _ = s._req = h(i), s._redirects && s.emit("redirect", s.url, _);
+  } else
+    _ = s._req = h(i);
+  i.timeout && _.on("timeout", () => {
+    b(s, _, "Opening handshake has timed out");
+  }), _.on("error", (u) => {
+    _ === null || _[lt] || (_ = s._req = null, ee(s, u));
+  }), _.on("response", (u) => {
+    const E = u.headers.location, $ = u.statusCode;
+    if (E && i.followRedirects && $ >= 300 && $ < 400) {
+      if (++s._redirects > i.maxRedirects) {
+        b(s, _, "Maximum redirects exceeded");
+        return;
+      }
+      _.abort();
+      let q;
+      try {
+        q = new me(E, e);
+      } catch {
+        const L = new SyntaxError(`Invalid URL: ${E}`);
+        ee(s, L);
+        return;
+      }
+      ht(s, q, t, r);
+    } else
+      s.emit("unexpected-response", _, u) || b(
+        s,
+        _,
+        `Unexpected server response: ${u.statusCode}`
+      );
+  }), _.on("upgrade", (u, E, $) => {
+    if (s.emit("upgrade", u), s.readyState !== m.CONNECTING)
+      return;
+    if (_ = s._req = null, u.headers.upgrade.toLowerCase() !== "websocket") {
+      b(s, E, "Invalid Upgrade header");
+      return;
+    }
+    const q = fs("sha1").update(c + us).digest("base64");
+    if (u.headers["sec-websocket-accept"] !== q) {
+      b(s, E, "Invalid Sec-WebSocket-Accept header");
+      return;
+    }
+    const D = u.headers["sec-websocket-protocol"];
+    let L;
+    if (D !== void 0 ? p.size ? p.has(D) || (L = "Server sent an invalid subprotocol") : L = "Server sent a subprotocol but none was requested" : p.size && (L = "Server sent no subprotocol"), L) {
+      b(s, E, L);
+      return;
+    }
+    D && (s._protocol = D);
+    const ke = u.headers["sec-websocket-extensions"];
+    if (ke !== void 0) {
+      if (!v) {
+        b(s, E, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
+        return;
+      }
+      let he;
+      try {
+        he = ys(ke);
+      } catch {
+        b(s, E, "Invalid Sec-WebSocket-Extensions header");
+        return;
+      }
+      const we = Object.keys(he);
+      if (we.length !== 1 || we[0] !== T.extensionName) {
+        b(s, E, "Server indicated an extension that was not requested");
+        return;
+      }
+      try {
+        v.accept(he[T.extensionName]);
+      } catch {
+        b(s, E, "Invalid Sec-WebSocket-Extensions header");
+        return;
+      }
+      s._extensions[T.extensionName] = v;
+    }
+    s.setSocket(E, $, {
+      generateMask: i.generateMask,
+      maxPayload: i.maxPayload,
+      skipUTF8Validation: i.skipUTF8Validation
+    });
+  }), i.finishRequest ? i.finishRequest(_, s) : _.end();
+}
+function ee(s, e) {
+  s._readyState = m.CLOSING, s.emit("error", e), s.emitClose();
+}
+function bs(s) {
+  return s.path = s.socketPath, ot.connect(s);
+}
+function xs(s) {
+  return s.path = void 0, !s.servername && s.servername !== "" && (s.servername = ot.isIP(s.host) ? "" : s.host), as.connect(s);
+}
+function b(s, e, t) {
+  s._readyState = m.CLOSING;
+  const r = new Error(t);
+  Error.captureStackTrace(r, b), e.setHeader ? (e[lt] = !0, e.abort(), e.socket && !e.socket.destroyed && e.socket.destroy(), process.nextTick(ee, s, r)) : (e.destroy(r), e.once("error", s.emit.bind(s, "error")), e.once("close", s.emitClose.bind(s)));
+}
+function ve(s, e, t) {
+  if (e) {
+    const r = vs(e).length;
+    s._socket ? s._sender._bufferedBytes += r : s._bufferedAmount += r;
+  }
+  if (t) {
+    const r = new Error(
+      `WebSocket is not open: readyState ${s.readyState} (${O[s.readyState]})`
+    );
+    process.nextTick(t, r);
+  }
+}
+function ks(s, e) {
+  const t = this[y];
+  t._closeFrameReceived = !0, t._closeMessage = e, t._closeCode = s, t._socket[y] !== void 0 && (t._socket.removeListener("data", fe), process.nextTick(ct, t._socket), s === 1005 ? t.close() : t.close(s, e));
+}
+function ws() {
+  const s = this[y];
+  s.isPaused || s._socket.resume();
+}
+function Os(s) {
+  const e = this[y];
+  e._socket[y] !== void 0 && (e._socket.removeListener("data", fe), process.nextTick(ct, e._socket), e.close(s[_s])), e.emit("error", s);
+}
+function Ye() {
+  this[y].emitClose();
+}
+function Cs(s, e) {
+  this[y].emit("message", s, e);
+}
+function Ts(s) {
+  const e = this[y];
+  e.pong(s, !e._isServer, at), e.emit("ping", s);
+}
+function Ls(s) {
+  this[y].emit("pong", s);
+}
+function ct(s) {
+  s.resume();
+}
+function ut() {
+  const s = this[y];
+  this.removeListener("close", ut), this.removeListener("data", fe), this.removeListener("end", dt), s._readyState = m.CLOSING;
+  let e;
+  !this._readableState.endEmitted && !s._closeFrameReceived && !s._receiver._writableState.errorEmitted && (e = s._socket.read()) !== null && s._receiver.write(e), s._receiver.end(), this[y] = void 0, clearTimeout(s._closeTimer), s._receiver._writableState.finished || s._receiver._writableState.errorEmitted ? s.emitClose() : (s._receiver.on("error", Ye), s._receiver.on("finish", Ye));
+}
+function fe(s) {
+  this[y]._receiver.write(s) || this.pause();
+}
+function dt() {
+  const s = this[y];
+  s._readyState = m.CLOSING, s._receiver.end(), this.end();
+}
+function _t() {
+  const s = this[y];
+  this.removeListener("error", _t), this.on("error", at), s && (s._readyState = m.CLOSING, this.destroy());
+}
+const Xs = /* @__PURE__ */ z(ft), { tokenChars: Ns } = ae;
+function Ps(s) {
+  const e = /* @__PURE__ */ new Set();
+  let t = -1, r = -1, i = 0;
+  for (i; i < s.length; i++) {
+    const o = s.charCodeAt(i);
+    if (r === -1 && Ns[o] === 1)
+      t === -1 && (t = i);
+    else if (i !== 0 && (o === 32 || o === 9))
+      r === -1 && t !== -1 && (r = i);
+    else if (o === 44) {
+      if (t === -1)
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      r === -1 && (r = i);
+      const l = s.slice(t, r);
+      if (e.has(l))
+        throw new SyntaxError(`The "${l}" subprotocol is duplicated`);
+      e.add(l), t = r = -1;
+    } else
+      throw new SyntaxError(`Unexpected character at index ${i}`);
+  }
+  if (t === -1 || r !== -1)
+    throw new SyntaxError("Unexpected end of input");
+  const n = s.slice(t, i);
+  if (e.has(n))
+    throw new SyntaxError(`The "${n}" subprotocol is duplicated`);
+  return e.add(n), e;
+}
+var Rs = { parse: Ps };
+const Us = S, ie = S, { createHash: Bs } = S, qe = nt, N = oe, $s = Rs, Ms = ft, { GUID: Is, kWebSocket: Ds } = U, Ws = /^[+/0-9A-Za-z]{22}==$/, Ke = 0, Xe = 1, pt = 2;
+class As extends Us {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+   *     permessage-deflate
+   * @param {Number} [options.port] The port where to bind the server
+   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+   *     server to use
+   * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
+   *     not to skip UTF-8 validation for text and close messages
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
+   *     class to use. It must be the `WebSocket` class or class that extends it
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(e, t) {
+    if (super(), e = {
+      maxPayload: 100 * 1024 * 1024,
+      skipUTF8Validation: !1,
+      perMessageDeflate: !1,
+      handleProtocols: null,
+      clientTracking: !0,
+      verifyClient: null,
+      noServer: !1,
+      backlog: null,
+      // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      WebSocket: Ms,
+      ...e
+    }, e.port == null && !e.server && !e.noServer || e.port != null && (e.server || e.noServer) || e.server && e.noServer)
+      throw new TypeError(
+        'One and only one of the "port", "server", or "noServer" options must be specified'
+      );
+    if (e.port != null ? (this._server = ie.createServer((r, i) => {
+      const n = ie.STATUS_CODES[426];
+      i.writeHead(426, {
+        "Content-Length": n.length,
+        "Content-Type": "text/plain"
+      }), i.end(n);
+    }), this._server.listen(
+      e.port,
+      e.host,
+      e.backlog,
+      t
+    )) : e.server && (this._server = e.server), this._server) {
+      const r = this.emit.bind(this, "connection");
+      this._removeListeners = js(this._server, {
+        listening: this.emit.bind(this, "listening"),
+        error: this.emit.bind(this, "error"),
+        upgrade: (i, n, o) => {
+          this.handleUpgrade(i, n, o, r);
+        }
+      });
+    }
+    e.perMessageDeflate === !0 && (e.perMessageDeflate = {}), e.clientTracking && (this.clients = /* @__PURE__ */ new Set(), this._shouldEmitClose = !1), this.options = e, this._state = Ke;
+  }
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer)
+      throw new Error('The server is operating in "noServer" mode');
+    return this._server ? this._server.address() : null;
+  }
+  /**
+   * Stop the server from accepting new connections and emit the `'close'` event
+   * when all existing connections are closed.
+   *
+   * @param {Function} [cb] A one-time listener for the `'close'` event
+   * @public
+   */
+  close(e) {
+    if (this._state === pt) {
+      e && this.once("close", () => {
+        e(new Error("The server is not running"));
+      }), process.nextTick(G, this);
+      return;
+    }
+    if (e && this.once("close", e), this._state !== Xe)
+      if (this._state = Xe, this.options.noServer || this.options.server)
+        this._server && (this._removeListeners(), this._removeListeners = this._server = null), this.clients ? this.clients.size ? this._shouldEmitClose = !0 : process.nextTick(G, this) : process.nextTick(G, this);
+      else {
+        const t = this._server;
+        this._removeListeners(), this._removeListeners = this._server = null, t.close(() => {
+          G(this);
+        });
+      }
+  }
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(e) {
+    if (this.options.path) {
+      const t = e.url.indexOf("?");
+      if ((t !== -1 ? e.url.slice(0, t) : e.url) !== this.options.path)
+        return !1;
+    }
+    return !0;
+  }
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(e, t, r, i) {
+    t.on("error", Ze);
+    const n = e.headers["sec-websocket-key"], o = +e.headers["sec-websocket-version"];
+    if (e.method !== "GET") {
+      R(this, e, t, 405, "Invalid HTTP method");
+      return;
+    }
+    if (e.headers.upgrade.toLowerCase() !== "websocket") {
+      R(this, e, t, 400, "Invalid Upgrade header");
+      return;
+    }
+    if (!n || !Ws.test(n)) {
+      R(this, e, t, 400, "Missing or invalid Sec-WebSocket-Key header");
+      return;
+    }
+    if (o !== 8 && o !== 13) {
+      R(this, e, t, 400, "Missing or invalid Sec-WebSocket-Version header");
+      return;
+    }
+    if (!this.shouldHandle(e)) {
+      H(t, 400);
+      return;
+    }
+    const l = e.headers["sec-websocket-protocol"];
+    let f = /* @__PURE__ */ new Set();
+    if (l !== void 0)
+      try {
+        f = $s.parse(l);
+      } catch {
+        R(this, e, t, 400, "Invalid Sec-WebSocket-Protocol header");
+        return;
+      }
+    const a = e.headers["sec-websocket-extensions"], c = {};
+    if (this.options.perMessageDeflate && a !== void 0) {
+      const h = new N(
+        this.options.perMessageDeflate,
+        !0,
+        this.options.maxPayload
+      );
+      try {
+        const p = qe.parse(a);
+        p[N.extensionName] && (h.accept(p[N.extensionName]), c[N.extensionName] = h);
+      } catch {
+        R(this, e, t, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
+        return;
+      }
+    }
+    if (this.options.verifyClient) {
+      const h = {
+        origin: e.headers[`${o === 8 ? "sec-websocket-origin" : "origin"}`],
+        secure: !!(e.socket.authorized || e.socket.encrypted),
+        req: e
+      };
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(h, (p, v, _, u) => {
+          if (!p)
+            return H(t, v || 401, _, u);
+          this.completeUpgrade(
+            c,
+            n,
+            f,
+            e,
+            t,
+            r,
+            i
+          );
+        });
+        return;
+      }
+      if (!this.options.verifyClient(h))
+        return H(t, 401);
+    }
+    this.completeUpgrade(c, n, f, e, t, r, i);
+  }
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {Object} extensions The accepted extensions
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Set} protocols The subprotocols
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @throws {Error} If called more than once with the same socket
+   * @private
+   */
+  completeUpgrade(e, t, r, i, n, o, l) {
+    if (!n.readable || !n.writable)
+      return n.destroy();
+    if (n[Ds])
+      throw new Error(
+        "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
+      );
+    if (this._state > Ke)
+      return H(n, 503);
+    const a = [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${Bs("sha1").update(t + Is).digest("base64")}`
+    ], c = new this.options.WebSocket(null);
+    if (r.size) {
+      const h = this.options.handleProtocols ? this.options.handleProtocols(r, i) : r.values().next().value;
+      h && (a.push(`Sec-WebSocket-Protocol: ${h}`), c._protocol = h);
+    }
+    if (e[N.extensionName]) {
+      const h = e[N.extensionName].params, p = qe.format({
+        [N.extensionName]: [h]
+      });
+      a.push(`Sec-WebSocket-Extensions: ${p}`), c._extensions = e;
+    }
+    this.emit("headers", a, i), n.write(a.concat(`\r
+`).join(`\r
+`)), n.removeListener("error", Ze), c.setSocket(n, o, {
+      maxPayload: this.options.maxPayload,
+      skipUTF8Validation: this.options.skipUTF8Validation
+    }), this.clients && (this.clients.add(c), c.on("close", () => {
+      this.clients.delete(c), this._shouldEmitClose && !this.clients.size && process.nextTick(G, this);
+    })), l(c, i);
+  }
+}
+var Fs = As;
+function js(s, e) {
+  for (const t of Object.keys(e))
+    s.on(t, e[t]);
+  return function() {
+    for (const r of Object.keys(e))
+      s.removeListener(r, e[r]);
+  };
+}
+function G(s) {
+  s._state = pt, s.emit("close");
+}
+function Ze() {
+  this.destroy();
+}
+function H(s, e, t, r) {
+  t = t || ie.STATUS_CODES[e], r = {
+    Connection: "close",
+    "Content-Type": "text/html",
+    "Content-Length": Buffer.byteLength(t),
+    ...r
+  }, s.once("finish", s.destroy), s.end(
+    `HTTP/1.1 ${e} ${ie.STATUS_CODES[e]}\r
+` + Object.keys(r).map((i) => `${i}: ${r[i]}`).join(`\r
+`) + `\r
+\r
+` + t
+  );
+}
+function R(s, e, t, r, i) {
+  if (s.listenerCount("wsClientError")) {
+    const n = new Error(i);
+    Error.captureStackTrace(n, R), s.emit("wsClientError", n, t, e);
+  } else
+    H(t, r, i);
+}
+const Zs = /* @__PURE__ */ z(Fs);
+export {
+  qs as Receiver,
+  Ks as Sender,
+  Xs as WebSocket,
+  Zs as WebSocketServer,
+  Vs as createWebSocketStream,
+  Xs as default
+};

gradio_dualvision/gradio_patches/templates/example/index.js

@@ -0,0 +1,95 @@
+const {
+  SvelteComponent: y,
+  append: m,
+  attr: n,
+  detach: b,
+  element: u,
+  init: k,
+  insert: p,
+  noop: w,
+  safe_not_equal: h,
+  space: o,
+  src_url_equal: v,
+  toggle_class: f
+} = window.__gradio__svelte__internal;
+function q(a) {
+  let e, l, _, g, i, c, s, d;
+  return {
+    c() {
+      e = u("div"), l = u("img"), g = o(), i = u("img"), s = o(), d = u("span"), v(l.src, _ = /*samples_dir*/
+      a[1] + /*value*/
+      a[0][0]) || n(l, "src", _), n(l, "class", "svelte-l4wpk0"), v(i.src, c = /*samples_dir*/
+      a[1] + /*value*/
+      a[0][1]) || n(i, "src", c), n(i, "class", "svelte-l4wpk0"), n(d, "class", "svelte-l4wpk0"), n(e, "class", "wrap svelte-l4wpk0"), f(
+        e,
+        "table",
+        /*type*/
+        a[2] === "table"
+      ), f(
+        e,
+        "gallery",
+        /*type*/
+        a[2] === "gallery"
+      ), f(
+        e,
+        "selected",
+        /*selected*/
+        a[3]
+      );
+    },
+    m(t, r) {
+      p(t, e, r), m(e, l), m(e, g), m(e, i), m(e, s), m(e, d);
+    },
+    p(t, [r]) {
+      r & /*samples_dir, value*/
+      3 && !v(l.src, _ = /*samples_dir*/
+      t[1] + /*value*/
+      t[0][0]) && n(l, "src", _), r & /*samples_dir, value*/
+      3 && !v(i.src, c = /*samples_dir*/
+      t[1] + /*value*/
+      t[0][1]) && n(i, "src", c), r & /*type*/
+      4 && f(
+        e,
+        "table",
+        /*type*/
+        t[2] === "table"
+      ), r & /*type*/
+      4 && f(
+        e,
+        "gallery",
+        /*type*/
+        t[2] === "gallery"
+      ), r & /*selected*/
+      8 && f(
+        e,
+        "selected",
+        /*selected*/
+        t[3]
+      );
+    },
+    i: w,
+    o: w,
+    d(t) {
+      t && b(e);
+    }
+  };
+}
+function I(a, e, l) {
+  let { value: _ } = e, { samples_dir: g } = e, { type: i } = e, { selected: c = !1 } = e;
+  return a.$$set = (s) => {
+    "value" in s && l(0, _ = s.value), "samples_dir" in s && l(1, g = s.samples_dir), "type" in s && l(2, i = s.type), "selected" in s && l(3, c = s.selected);
+  }, [_, g, i, c];
+}
+class C extends y {
+  constructor(e) {
+    super(), k(this, e, I, q, h, {
+      value: 0,
+      samples_dir: 1,
+      type: 2,
+      selected: 3
+    });
+  }
+}
+export {
+  C as default
+};

gradio_dualvision/gradio_patches/templates/example/style.css

@@ -0,0 +1 @@
+.wrap.svelte-l4wpk0.svelte-l4wpk0{position:relative;height:var(--size-64);width:var(--size-40);overflow:hidden;border-radius:var(--radius-lg)}img.svelte-l4wpk0.svelte-l4wpk0{height:var(--size-64);width:var(--size-40);position:absolute;object-fit:cover}.wrap.selected.svelte-l4wpk0.svelte-l4wpk0{border-color:var(--color-accent)}.wrap.svelte-l4wpk0 img.svelte-l4wpk0:first-child{clip-path:inset(0 50% 0 0%)}.wrap.svelte-l4wpk0 img.svelte-l4wpk0:nth-of-type(2){clip-path:inset(0 0 0 50%)}span.svelte-l4wpk0.svelte-l4wpk0{position:absolute;top:0;left:calc(50% - .75px);height:var(--size-64);width:1.5px;background:var(--border-color-primary)}.table.svelte-l4wpk0.svelte-l4wpk0{margin:0 auto;border:2px solid var(--border-color-primary);border-radius:var(--radius-lg)}.gallery.svelte-l4wpk0.svelte-l4wpk0{border:2px solid var(--border-color-primary);object-fit:cover}

gradio_dualvision/version.py

@@ -0,0 +1,25 @@
+# Copyright 2023-2025 Marigold Team, ETH Zürich. All rights reserved.
+# This work is licensed under the Creative Commons Attribution-ShareAlike 4.0 International License.
+# See https://creativecommons.org/licenses/by-sa/4.0/ for details.
+# --------------------------------------------------------------------------
+# DualVision is a Gradio template app for image processing. It was developed
+# to support the Marigold project. If you find this code useful, we kindly
+# ask you to cite our most relevant papers.
+# More information about Marigold:
+#   https://marigoldmonodepth.github.io
+#   https://marigoldcomputervision.github.io
+# Efficient inference pipelines are now part of diffusers:
+#   https://huggingface.co/docs/diffusers/using-diffusers/marigold_usage
+#   https://huggingface.co/docs/diffusers/api/pipelines/marigold
+# Examples of trained models and live demos:
+#   https://huggingface.co/prs-eth
+# Related projects:
+#   https://marigolddepthcompletion.github.io/
+#   https://rollingdepth.github.io/
+# Citation (BibTeX):
+#   https://github.com/prs-eth/Marigold#-citation
+#   https://github.com/prs-eth/Marigold-DC#-citation
+#   https://github.com/prs-eth/rollingdepth#-citation
+# --------------------------------------------------------------------------
+
+__version__ = "0.1.0"

model/__init__.py

@@ -0,0 +1,2 @@
+from .hyper import Hypernetwork
+from .thera import build_thera

model/convnext.py

@@ -0,0 +1,55 @@
+import flax.linen as nn
+from jaxtyping import Array, ArrayLike
+
+
+class ConvNeXtBlock(nn.Module):
+    """ConvNext block. See Fig.4 in "A ConvNet for the 2020s" by Liu et al.
+
+    https://openaccess.thecvf.com/content/CVPR2022/papers/Liu_A_ConvNet_for_the_2020s_CVPR_2022_paper.pdf
+    """
+    n_dims: int = 64
+    kernel_size: int = 3  # 7 in the paper's version
+    group_features: bool = False
+
+    def setup(self) -> None:
+        self.residual = nn.Sequential([
+            nn.Conv(self.n_dims, kernel_size=(self.kernel_size, self.kernel_size), use_bias=False,
+                    feature_group_count=self.n_dims if self.group_features else 1),
+            nn.LayerNorm(),
+            nn.Conv(4 * self.n_dims, kernel_size=(1, 1)),
+            nn.gelu,
+            nn.Conv(self.n_dims, kernel_size=(1, 1)),
+        ])
+
+    def __call__(self, x: ArrayLike) -> Array:
+        return x + self.residual(x)
+
+
+class Projection(nn.Module):
+    n_dims: int
+
+    @nn.compact
+    def __call__(self, x: ArrayLike) -> Array:
+        x = nn.LayerNorm()(x)
+        x = nn.Conv(self.n_dims, (1, 1))(x)
+        return x
+
+
+class ConvNeXt(nn.Module):
+    block_defs: list[tuple]
+
+    def setup(self) -> None:
+        layers = []
+        current_size = self.block_defs[0][0]
+        for block_def in self.block_defs:
+            if block_def[0] != current_size:
+                layers.append(Projection(block_def[0]))
+            layers.append(ConvNeXtBlock(*block_def))
+            current_size = block_def[0]
+        self.layers = layers
+
+    def __call__(self, x: ArrayLike, _: bool) -> Array:
+        for layer in self.layers:
+            x = layer(x)
+        return x
+

model/edsr.py

@@ -0,0 +1,122 @@
+# from https://github.com/isaaccorley/jax-enhance
+
+from functools import partial
+from typing import Any, Sequence, Callable
+
+import jax.numpy as jnp
+import flax.linen as nn
+from flax.core.frozen_dict import freeze
+import einops
+
+
+class PixelShuffle(nn.Module):
+    scale_factor: int
+
+    def setup(self):
+        self.layer = partial(
+            einops.rearrange,
+            pattern="b h w (c h2 w2) -> b (h h2) (w w2) c",
+            h2=self.scale_factor,
+            w2=self.scale_factor
+        )
+
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        return self.layer(x)
+
+
+class ResidualBlock(nn.Module):
+    channels: int
+    kernel_size: Sequence[int]
+    res_scale: float
+    activation: Callable
+    dtype: Any = jnp.float32
+
+    def setup(self):
+        self.body = nn.Sequential([
+            nn.Conv(features=self.channels, kernel_size=self.kernel_size, dtype=self.dtype),
+            self.activation,
+            nn.Conv(features=self.channels, kernel_size=self.kernel_size, dtype=self.dtype),
+        ])
+
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        return x + self.body(x)
+
+
+class UpsampleBlock(nn.Module):
+    num_upsamples: int
+    channels: int
+    kernel_size: Sequence[int]
+    dtype: Any = jnp.float32
+
+    def setup(self):
+        layers = []
+        for _ in range(self.num_upsamples):
+            layers.extend([
+                nn.Conv(features=self.channels * 2 ** 2, kernel_size=self.kernel_size, dtype=self.dtype),
+                PixelShuffle(scale_factor=2),
+            ])
+        self.layers = layers
+
+    def __call__(self, x: jnp.ndarray) -> jnp.ndarray:
+        for layer in self.layers:
+            x = layer(x)
+        return x
+
+
+class EDSR(nn.Module):
+    """Enhanced Deep Residual Networks for Single Image Super-Resolution https://arxiv.org/pdf/1707.02921v1.pdf"""
+    scale_factor: int
+    channels: int = 3
+    num_blocks: int = 32
+    num_feats: int = 256
+    dtype: Any = jnp.float32
+
+    def setup(self):
+        # pre res blocks layer
+        self.head = nn.Sequential([nn.Conv(features=self.num_feats, kernel_size=(3, 3), dtype=self.dtype)])
+
+        # res blocks
+        res_blocks = [
+            ResidualBlock(channels=self.num_feats, kernel_size=(3, 3), res_scale=0.1, activation=nn.relu, dtype=self.dtype)
+            for i in range(self.num_blocks)
+        ]
+        res_blocks.append(nn.Conv(features=self.num_feats, kernel_size=(3, 3), dtype=self.dtype))
+        self.body = nn.Sequential(res_blocks)
+
+    def __call__(self, x: jnp.ndarray, _=None) -> jnp.ndarray:
+        x = self.head(x)
+        x = x + self.body(x)
+        return x
+
+
+def convert_edsr_checkpoint(torch_dict, no_upsampling=True):
+    def convert(in_dict):
+        top_keys = set([k.split('.')[0] for k in in_dict.keys()])
+        leaves = set([k for k in in_dict.keys() if '.' not in k])
+
+        # convert leaves
+        out_dict = {}
+        for l in leaves:
+            if l == 'weight':
+                out_dict['kernel'] = jnp.asarray(in_dict[l]).transpose((2, 3, 1, 0))
+            elif l == 'bias':
+                out_dict[l] = jnp.asarray(in_dict[l])
+            else:
+                out_dict[l] = in_dict[l]
+
+        for top_key in top_keys.difference(leaves):
+            new_top_key = 'layers_' + top_key if top_key.isdigit() else top_key
+            out_dict[new_top_key] = convert(
+                {k[len(top_key) + 1:]: v for k, v in in_dict.items() if k.startswith(top_key)})
+        return out_dict
+
+    converted = convert(torch_dict)
+
+    # remove unwanted keys
+    if no_upsampling:
+        del converted['tail']
+
+    for k in ('add_mean', 'sub_mean'):
+        del converted[k]
+
+    return freeze(converted)

model/hyper.py

@@ -0,0 +1,41 @@
+import math
+
+import jax
+import jax.numpy as jnp
+import flax.linen as nn
+from jaxtyping import Array, ArrayLike, PyTreeDef
+import numpy as np
+
+from utils import interpolate_grid
+
+
+class Hypernetwork(nn.Module):
+    encoder: nn.Module
+    refine: nn.Module
+    output_params_shape: list[tuple]  # e.g. [(16,), (32, 32), ...]
+    tree_def: PyTreeDef  # used to reconstruct the parameter sets
+
+    def setup(self):
+        # one layer 1x1 conv to calculate field params, as in SIREN paper
+        output_size = sum(math.prod(s) for s in self.output_params_shape)
+        self.out_conv = nn.Conv(output_size, kernel_size=(1, 1), use_bias=True)
+
+    def get_encoding(self, source: ArrayLike, training=False) -> Array:
+        """Convenience method for whole-image evaluation"""
+        return self.refine(self.encoder(source, training), training)
+
+    def get_params_at_coords(self, encoding: ArrayLike, coords: ArrayLike) -> Array:
+        encoding = interpolate_grid(coords, encoding)
+        phi_params = self.out_conv(encoding)
+
+        # reshape to output params shape
+        phi_params = jnp.split(
+            phi_params, np.cumsum([math.prod(s) for s in self.output_params_shape[:-1]]), axis=-1)
+        phi_params = [jnp.reshape(p, p.shape[:-1] + s) for p, s in
+                      zip(phi_params, self.output_params_shape)]
+
+        return jax.tree_util.tree_unflatten(self.tree_def, phi_params)
+
+    def __call__(self, source: ArrayLike, target_coords: ArrayLike, training=False) -> Array:
+        encoding = self.get_encoding(source, training)
+        return self.get_params_at_coords(encoding, target_coords)

model/init.py

@@ -0,0 +1,24 @@
+from typing import Callable
+
+import jax
+import jax.numpy as jnp
+from jaxtyping import Array
+
+
+def uniform_between(a: float, b: float, dtype=jnp.float32) -> Callable:
+    def init(key, shape, dtype=dtype) -> Array:
+        return jax.random.uniform(key, shape, dtype=dtype, minval=a, maxval=b)
+    return init
+
+
+def linear_up(scale: float) -> Callable:
+    def init(key, shape, dtype=jnp.float32) -> Array:
+        assert shape[-2] == 2
+        keys = jax.random.split(key, 2)
+        norm = jnp.pi * scale * (
+                jax.random.uniform(keys[0], shape=(1, shape[-1])) ** .5)
+        theta = 2 * jnp.pi * jax.random.uniform(keys[1], shape=(1, shape[-1]))
+        x = norm * jnp.cos(theta)
+        y = norm * jnp.sin(theta)
+        return jnp.concatenate([x, y], axis=-2).astype(dtype)
+    return init

model/rdn.py

@@ -0,0 +1,72 @@
+# Residual Dense Network for Image Super-Resolution
+# https://arxiv.org/abs/1802.08797
+# modified from: https://github.com/thstkdgus35/EDSR-PyTorch
+
+import jax.numpy as jnp
+import flax.linen as nn
+
+
+class RDB_Conv(nn.Module):
+    growRate: int
+    kSize: int = 3
+
+    @nn.compact
+    def __call__(self, x):
+        out = nn.Sequential([
+            nn.Conv(self.growRate, (self.kSize, self.kSize), padding=(self.kSize-1)//2),
+            nn.activation.relu
+        ])(x)
+        return jnp.concatenate((x, out), -1)
+
+
+class RDB(nn.Module):
+    growRate0: int
+    growRate: int
+    nConvLayers: int
+
+    @nn.compact
+    def __call__(self, x):
+        res = x
+
+        for c in range(self.nConvLayers):
+            x = RDB_Conv(self.growRate)(x)
+
+        x = nn.Conv(self.growRate0, (1, 1))(x)
+
+        return x + res
+
+
+class RDN(nn.Module):
+    G0: int = 64
+    RDNkSize: int = 3
+    RDNconfig: str = 'B'
+    scale: int = 2
+    n_colors: int = 3
+
+    @nn.compact
+    def __call__(self, x, _=None):
+        D, C, G = {
+            'A': (20, 6, 32),
+            'B': (16, 8, 64),
+        }[self.RDNconfig]
+
+        # Shallow feature extraction
+        f_1 = nn.Conv(self.G0, (self.RDNkSize, self.RDNkSize))(x)
+        x = nn.Conv(self.G0, (self.RDNkSize, self.RDNkSize))(f_1)
+
+        # Redidual dense blocks and dense feature fusion
+        RDBs_out = []
+        for i in range(D):
+            x = RDB(self.G0, G, C)(x)
+            RDBs_out.append(x)
+
+        x = jnp.concatenate(RDBs_out, -1)
+
+        # Global Feature Fusion
+        x = nn.Sequential([
+            nn.Conv(self.G0, (1, 1)),
+            nn.Conv(self.G0, (self.RDNkSize, self.RDNkSize))
+        ])(x)
+
+        x = x + f_1
+        return x

model/swin_ir.py

@@ -0,0 +1,532 @@
+import math
+from typing import Callable, Optional, Iterable
+
+import numpy as np
+import jax
+import jax.numpy as jnp
+import flax.linen as nn
+from jaxtyping import Array
+
+
+def trunc_normal(mean=0., std=1., a=-2., b=2., dtype=jnp.float32) -> Callable:
+    """Truncated normal initialization function"""
+
+    def init(key, shape, dtype=dtype) -> Array:
+        # https://github.com/huggingface/pytorch-image-models/blob/main/timm/layers/weight_init.py
+        def norm_cdf(x):
+            # Computes standard normal cumulative distribution function
+            return (1. + math.erf(x / math.sqrt(2.))) / 2.
+
+        l = norm_cdf((a - mean) / std)
+        u = norm_cdf((b - mean) / std)
+        out = jax.random.uniform(key, shape, dtype=dtype, minval=2 * l - 1, maxval=2 * u - 1)
+        out = jax.scipy.special.erfinv(out) * std * math.sqrt(2.) + mean
+        return jnp.clip(out, a, b)
+
+    return init
+
+
+def Dense(features, use_bias=True, kernel_init=trunc_normal(std=.02), bias_init=nn.initializers.zeros):
+    return nn.Dense(features, use_bias=use_bias, kernel_init=kernel_init, bias_init=bias_init)
+
+
+def LayerNorm():
+    """torch LayerNorm uses larger epsilon by default"""
+    return nn.LayerNorm(epsilon=1e-05)
+
+
+class Mlp(nn.Module):
+
+    in_features: int
+    hidden_features: int = None
+    out_features: int = None
+    act_layer: Callable = nn.gelu
+    drop: float = 0.0
+
+    @nn.compact
+    def __call__(self, x, training: bool):
+        x = nn.Dense(self.hidden_features or self.in_features)(x)
+        x = self.act_layer(x)
+        x = nn.Dropout(self.drop, deterministic=not training)(x)
+        x = nn.Dense(self.out_features or self.in_features)(x)
+        x = nn.Dropout(self.drop, deterministic=not training)(x)
+        return x
+
+
+def window_partition(x, window_size: int):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.reshape((B, H // window_size, window_size, W // window_size, window_size, C))
+    windows = x.transpose((0, 1, 3, 2, 4, 5)).reshape((-1, window_size, window_size, C))
+    return windows
+
+
+def window_reverse(windows, window_size: int, H: int, W: int):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.reshape((B, H // window_size, W // window_size, window_size, window_size, -1))
+    x = x.transpose((0, 1, 3, 2, 4, 5)).reshape((B, H, W, -1))
+    return x
+
+
+class DropPath(nn.Module):
+    """
+    Implementation referred from https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/layers/drop.py
+    """
+
+    dropout_prob: float = 0.1
+    deterministic: Optional[bool] = None
+
+    @nn.compact
+    def __call__(self, input, training):
+        if not training:
+            return input
+        keep_prob = 1 - self.dropout_prob
+        shape = (input.shape[0],) + (1,) * (input.ndim - 1)
+        rng = self.make_rng("dropout")
+        random_tensor = keep_prob + jax.random.uniform(rng, shape)
+        random_tensor = jnp.floor(random_tensor)
+        return jnp.divide(input, keep_prob) * random_tensor
+
+
+class WindowAttention(nn.Module):
+    dim: int
+    window_size: Iterable[int]
+    num_heads: int
+    qkv_bias: bool = True
+    qk_scale: Optional[float] = None
+    att_drop: float = 0.0
+    proj_drop: float = 0.0
+
+    def make_rel_pos_index(self):
+        h_indices = np.arange(0, self.window_size[0])
+        w_indices = np.arange(0, self.window_size[1])
+        indices = np.stack(np.meshgrid(w_indices, h_indices, indexing="ij"))
+        flatten_indices = np.reshape(indices, (2, -1))
+        relative_indices = flatten_indices[:, :, None] - flatten_indices[:, None, :]
+        relative_indices = np.transpose(relative_indices, (1, 2, 0))
+        relative_indices[:, :, 0] += self.window_size[0] - 1
+        relative_indices[:, :, 1] += self.window_size[1] - 1
+        relative_indices[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_pos_index = np.sum(relative_indices, -1)
+        return relative_pos_index
+
+    @nn.compact
+    def __call__(self, inputs, mask, training):
+        rpbt = self.param(
+            "relative_position_bias_table",
+            trunc_normal(std=.02),
+            (
+                (2 * self.window_size[0] - 1) * (2 * self.window_size[1] - 1),
+                self.num_heads,
+            ),
+        )
+
+        #relative_pos_index = self.variable(
+        #    "variables", "relative_position_index", self.get_rel_pos_index
+        #)
+
+        batch, n, channels = inputs.shape
+        qkv = nn.Dense(self.dim * 3, use_bias=self.qkv_bias, name="qkv")(inputs)
+        qkv = qkv.reshape(batch, n, 3, self.num_heads, channels // self.num_heads)
+        qkv = jnp.transpose(qkv, (2, 0, 3, 1, 4))
+        q, k, v = qkv[0], qkv[1], qkv[2]
+
+        scale = self.qk_scale or (self.dim // self.num_heads) ** -0.5
+        q = q * scale
+        att = q @ jnp.swapaxes(k, -2, -1)
+
+        rel_pos_bias = jnp.reshape(
+            rpbt[np.reshape(self.make_rel_pos_index(), (-1))],
+            (
+                self.window_size[0] * self.window_size[1],
+                self.window_size[0] * self.window_size[1],
+                -1,
+            ),
+        )
+        rel_pos_bias = jnp.transpose(rel_pos_bias, (2, 0, 1))
+        att += jnp.expand_dims(rel_pos_bias, 0)
+
+        if mask is not None:
+            att = jnp.reshape(
+                att, (batch // mask.shape[0], mask.shape[0], self.num_heads, n, n)
+            )
+            att = att + jnp.expand_dims(jnp.expand_dims(mask, 1), 0)
+            att = jnp.reshape(att, (-1, self.num_heads, n, n))
+            att = jax.nn.softmax(att)
+
+        else:
+            att = jax.nn.softmax(att)
+
+        att = nn.Dropout(self.att_drop)(att, deterministic=not training)
+
+        x = jnp.reshape(jnp.swapaxes(att @ v, 1, 2), (batch, n, channels))
+        x = nn.Dense(self.dim, name="proj")(x)
+        x = nn.Dropout(self.proj_drop)(x, deterministic=not training)
+        return x
+
+
+class SwinTransformerBlock(nn.Module):
+
+    dim: int
+    input_resolution: tuple[int]
+    num_heads: int
+    window_size: int = 7
+    shift_size: int = 0
+    mlp_ratio: float = 4.
+    qkv_bias: bool = True
+    qk_scale: Optional[float] = None
+    drop: float = 0.
+    attn_drop: float = 0.
+    drop_path: float = 0.
+    act_layer: Callable = nn.activation.gelu
+    norm_layer: Callable = LayerNorm
+
+    @staticmethod
+    def make_att_mask(shift_size, window_size, height, width):
+        if shift_size > 0:
+            mask = jnp.zeros([1, height, width, 1])
+            h_slices = (
+                slice(0, -window_size),
+                slice(-window_size, -shift_size),
+                slice(-shift_size, None),
+            )
+            w_slices = (
+                slice(0, -window_size),
+                slice(-window_size, -shift_size),
+                slice(-shift_size, None),
+            )
+
+            count = 0
+            for h in h_slices:
+                for w in w_slices:
+                    mask = mask.at[:, h, w, :].set(count)
+                    count += 1
+
+            mask_windows = window_partition(mask, window_size)
+            mask_windows = jnp.reshape(mask_windows, (-1, window_size * window_size))
+            att_mask = jnp.expand_dims(mask_windows, 1) - jnp.expand_dims(mask_windows, 2)
+            att_mask = jnp.where(att_mask != 0.0, float(-100.0), att_mask)
+            att_mask = jnp.where(att_mask == 0.0, float(0.0), att_mask)
+        else:
+            att_mask = None
+
+        return att_mask
+
+    @nn.compact
+    def __call__(self, x, x_size, training):
+        H, W = x_size
+        B, L, C = x.shape
+
+        if min(self.input_resolution) <= self.window_size:
+            # if window size is larger than input resolution, we don't partition windows
+            self.shift_size = 0
+            self.window_size = min(self.input_resolution)
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        shortcut = x
+        x = self.norm_layer()(x)
+        x = x.reshape((B, H, W, C))
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = jnp.roll(x, (-self.shift_size, -self.shift_size), axis=(1, 2))
+        else:
+            shifted_x = x
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.reshape((-1, self.window_size * self.window_size, C))  # nW*B, window_size*window_size, C
+
+        #attn_mask = self.variable(
+        #    "variables",
+        #    "attn_mask",
+        #    self.get_att_mask,
+        #    self.shift_size,
+        #    self.window_size,
+        #    self.input_resolution[0],
+        #    self.input_resolution[1]
+        #)
+
+        attn_mask = self.make_att_mask(self.shift_size, self.window_size, *self.input_resolution)
+
+        attn = WindowAttention(self.dim, (self.window_size, self.window_size), self.num_heads,
+                               self.qkv_bias, self.qk_scale, self.attn_drop, self.drop)
+        if self.input_resolution == x_size:
+            attn_windows = attn(x_windows, attn_mask, training)  # nW*B, window_size*window_size, C
+        else:
+            # test time
+            assert not training
+            test_mask = self.make_att_mask(self.shift_size, self.window_size, *x_size)
+            attn_windows = attn(x_windows, test_mask, training=False)
+
+        # merge windows
+        attn_windows = attn_windows.reshape((-1, self.window_size, self.window_size, C))
+        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = jnp.roll(shifted_x, (self.shift_size, self.shift_size), axis=(1, 2))
+        else:
+            x = shifted_x
+
+        x = x.reshape((B, H * W, C))
+
+        # FFN
+        x = shortcut + DropPath(self.drop_path)(x, training)
+
+        norm = self.norm_layer()(x)
+        mlp = Mlp(in_features=self.dim, hidden_features=int(self.dim * self.mlp_ratio),
+                  act_layer=self.act_layer, drop=self.drop)(norm, training)
+        x = x + DropPath(self.drop_path)(mlp, training)
+
+        return x
+
+
+class PatchMerging(nn.Module):
+    inp_res: Iterable[int]
+    dim: int
+    norm_layer: Callable = LayerNorm
+
+    @nn.compact
+    def __call__(self, inputs):
+        batch, n, channels = inputs.shape
+        height, width = self.inp_res[0], self.inp_res[1]
+        x = jnp.reshape(inputs, (batch, height, width, channels))
+
+        x0 = x[:, 0::2, 0::2, :]
+        x1 = x[:, 1::2, 0::2, :]
+        x2 = x[:, 0::2, 1::2, :]
+        x3 = x[:, 1::2, 1::2, :]
+
+        x = jnp.concatenate([x0, x1, x2, x3], axis=-1)
+        x = jnp.reshape(x, (batch, -1, 4 * channels))
+        x = self.norm_layer()(x)
+        x = nn.Dense(2 * self.dim, use_bias=False)(x)
+        return x
+
+
+class BasicLayer(nn.Module):
+
+    dim: int
+    input_resolution: int
+    depth: int
+    num_heads: int
+    window_size: int
+    mlp_ratio: float = 4.
+    qkv_bias: bool = True
+    qk_scale: Optional[float] = None
+    drop: float = 0.
+    attn_drop: float = 0.
+    drop_path: float = 0.
+    norm_layer: Callable = LayerNorm
+    downsample: Optional[Callable] = None
+
+    @nn.compact
+    def __call__(self, x, x_size, training):
+        for i in range(self.depth):
+            x = SwinTransformerBlock(
+                self.dim,
+                self.input_resolution,
+                self.num_heads,
+                self.window_size,
+                0 if (i % 2 == 0) else self.window_size // 2,
+                self.mlp_ratio,
+                self.qkv_bias,
+                self.qk_scale,
+                self.drop,
+                self.attn_drop,
+                self.drop_path[i] if isinstance(self.drop_path, (list, tuple)) else self.drop_path,
+                norm_layer=self.norm_layer
+            )(x, x_size, training)
+
+        if self.downsample is not None:
+            x = self.downsample(self.input_resolution, dim=self.dim, norm_layer=self.norm_layer)(x)
+
+        return x
+
+
+class RSTB(nn.Module):
+
+    dim: int
+    input_resolution: int
+    depth: int
+    num_heads: int
+    window_size: int
+    mlp_ratio: float = 4.
+    qkv_bias: bool = True
+    qk_scale: Optional[float] = None
+    drop: float = 0.
+    attn_drop: float = 0.
+    drop_path: float = 0.
+    norm_layer: Callable = LayerNorm
+    downsample: Optional[Callable] = None
+    img_size: int = 224,
+    patch_size: int = 4,
+    resi_connection: str = '1conv'
+
+    @nn.compact
+    def __call__(self, x, x_size, training):
+        res = x
+        x = BasicLayer(dim=self.dim,
+                       input_resolution=self.input_resolution,
+                       depth=self.depth,
+                       num_heads=self.num_heads,
+                       window_size=self.window_size,
+                       mlp_ratio=self.mlp_ratio,
+                       qkv_bias=self.qkv_bias, qk_scale=self.qk_scale,
+                       drop=self.drop, attn_drop=self.attn_drop,
+                       drop_path=self.drop_path,
+                       norm_layer=self.norm_layer,
+                       downsample=self.downsample)(x, x_size, training)
+
+        x = PatchUnEmbed(embed_dim=self.dim)(x, x_size)
+
+        # resi_connection == '1conv':
+        x = nn.Conv(self.dim, (3, 3))(x)
+
+        x = PatchEmbed()(x)
+
+        return x + res
+
+
+class PatchEmbed(nn.Module):
+    norm_layer: Optional[Callable] = None
+
+    @nn.compact
+    def __call__(self, x):
+        x = x.reshape((x.shape[0], -1, x.shape[-1]))  # B Ph Pw C -> B Ph*Pw C
+        if self.norm_layer is not None:
+            x = self.norm_layer()(x)
+        return x
+
+
+class PatchUnEmbed(nn.Module):
+    embed_dim: int = 96
+
+    @nn.compact
+    def __call__(self, x, x_size):
+        B, HW, C = x.shape
+        x = x.reshape((B, x_size[0], x_size[1], self.embed_dim))
+        return x
+
+
+class SwinIR(nn.Module):
+    r""" SwinIR JAX implementation
+    Args:
+        img_size (int | tuple(int)): Input image size. Default 64
+        patch_size (int | tuple(int)): Patch size. Default: 1
+        in_chans (int): Number of input image channels. Default: 3
+        embed_dim (int): Patch embedding dimension. Default: 96
+        depths (tuple(int)): Depth of each Swin Transformer layer.
+        num_heads (tuple(int)): Number of attention heads in different layers.
+        window_size (int): Window size. Default: 7
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
+        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
+        drop_rate (float): Dropout rate. Default: 0
+        attn_drop_rate (float): Attention dropout rate. Default: 0
+        drop_path_rate (float): Stochastic depth rate. Default: 0.1
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True
+        upscale: Upscale factor. 2/3/4/8 for image SR, 1 for denoising and compress artifact reduction
+        img_range: Image range. 1. or 25I think5.
+    """
+
+    img_size: int = 48
+    patch_size: int = 1
+    in_chans: int = 3
+    embed_dim: int = 180
+    depths: tuple = (6, 6, 6, 6, 6, 6)
+    num_heads: tuple = (6, 6, 6, 6, 6, 6)
+    window_size: int = 8
+    mlp_ratio: float = 2.
+    qkv_bias: bool = True
+    qk_scale: Optional[float] = None
+    drop_rate: float = 0.
+    attn_drop_rate: float = 0.
+    drop_path_rate: float = 0.1
+    norm_layer: Callable = LayerNorm
+    ape: bool = False
+    patch_norm: bool = True
+    upscale: int = 2
+    img_range: float = 1.
+    num_feat: int = 64
+
+    def pad(self, x):
+        _, h, w, _ = x.shape
+        mod_pad_h = (self.window_size - h % self.window_size) % self.window_size
+        mod_pad_w = (self.window_size - w % self.window_size) % self.window_size
+        x = jnp.pad(x, ((0, 0), (0, mod_pad_h), (0, mod_pad_w), (0, 0)), 'reflect')
+        return x
+
+    @nn.compact
+    def __call__(self, x, training):
+        _, h_before, w_before, _ = x.shape
+        x = self.pad(x)
+        _, h, w, _ = x.shape
+        patches_resolution = [self.img_size // self.patch_size] * 2
+        num_patches = patches_resolution[0] * patches_resolution[1]
+
+        # conv_first
+        x = nn.Conv(self.embed_dim, (3, 3))(x)
+        res = x
+
+        # feature extraction
+        x_size = (h, w)
+        x = PatchEmbed(self.norm_layer if self.patch_norm else None)(x)
+
+        if self.ape:
+            absolute_pos_embed = \
+                self.param('ape', trunc_normal(std=.02), (1, num_patches, self.embed_dim))
+            x = x + absolute_pos_embed
+
+        x = nn.Dropout(self.drop_rate, deterministic=not training)(x)
+
+        dpr = [x.item() for x in np.linspace(0, self.drop_path_rate, sum(self.depths))]
+        for i_layer in range(len(self.depths)):
+            x = RSTB(
+                dim=self.embed_dim,
+                input_resolution=(patches_resolution[0], patches_resolution[1]),
+                depth=self.depths[i_layer],
+                num_heads=self.num_heads[i_layer],
+                window_size=self.window_size,
+                mlp_ratio=self.mlp_ratio,
+                qkv_bias=self.qkv_bias, qk_scale=self.qk_scale,
+                drop=self.drop_rate, attn_drop=self.attn_drop_rate,
+                drop_path=dpr[sum(self.depths[:i_layer]):sum(self.depths[:i_layer + 1])],
+                norm_layer=self.norm_layer,
+                downsample=None,
+                img_size=self.img_size,
+                patch_size=self.patch_size)(x, x_size, training)
+
+        x = self.norm_layer()(x)  # B L C
+        x = PatchUnEmbed(self.embed_dim)(x, x_size)
+
+        # conv_after_body
+        x = nn.Conv(self.embed_dim, (3, 3))(x)
+        x = x + res
+
+        # conv_before_upsample
+        x = nn.activation.leaky_relu(nn.Conv(self.num_feat, (3, 3))(x))
+
+        # revert padding
+        x = x[:, :-(h - h_before) or None, :-(w - w_before) or None]
+        return x

model/tail.py

@@ -0,0 +1,18 @@
+import flax.linen as nn
+
+from .convnext import ConvNeXt 
+from .swin_ir import SwinIR
+
+
+def build_tail(size: str):
+    """ Convenience function to build the three tails described in the paper. """
+    if size == 'air':
+        return lambda x, _: x
+    elif size == 'plus':
+        blocks = [(64, 3, True)] * 6 + [(96, 3, True)] * 7 + [(128, 3, True)] * 3
+        return ConvNeXt(blocks)
+    elif size == 'pro':
+        return SwinIR(depths=[7, 6], num_heads=[6, 6])
+    else:
+        raise NotImplementedError('size: ' + size)
+

model/thera.py

@@ -0,0 +1,175 @@
+import math
+
+import jax
+from flax.core import unfreeze, freeze
+import jax.numpy as jnp
+import flax.linen as nn
+from jaxtyping import Array, ArrayLike, PyTree
+
+from .edsr import EDSR
+from .rdn import RDN
+from .hyper import Hypernetwork
+from .tail import build_tail
+from .init import uniform_between, linear_up
+from utils import make_grid, interpolate_grid, repeat_vmap
+
+
+class Thermal(nn.Module):
+    w0_scale: float = 1.
+
+    @nn.compact
+    def __call__(self, x: ArrayLike, t, norm, k) -> Array:
+        phase = self.param('phase', nn.initializers.uniform(.5), x.shape[-1:])
+        return jnp.sin(self.w0_scale * x + phase) * jnp.exp(-(self.w0_scale * norm)**2 * k * t)
+
+
+class TheraField(nn.Module):
+    dim_hidden: int
+    dim_out: int
+    w0: float = 1.
+    c: float = 6.
+
+    @nn.compact
+    def __call__(self, x: ArrayLike, t: ArrayLike, k: ArrayLike, components: ArrayLike) -> Array:
+        # coordinate projection according to shared components ("first layer")
+        x = x @ components
+
+        # thermal activations
+        norm = jnp.linalg.norm(components, axis=-2)
+        x = Thermal(self.w0)(x, t, norm, k)
+
+        # linear projection from hidden to output space ("second layer")
+        w_std = math.sqrt(self.c / self.dim_hidden) / self.w0
+        dense_init_fn = uniform_between(-w_std, w_std)
+        x = nn.Dense(self.dim_out, kernel_init=dense_init_fn, use_bias=False)(x)
+
+        return x
+
+
+class Thera:
+
+    def __init__(
+            self,
+            hidden_dim: int,
+            out_dim: int,
+            backbone: nn.Module,
+            tail: nn.Module,
+            k_init: float = None,
+            components_init_scale: float = None
+    ):
+        self.hidden_dim = hidden_dim
+        self.k_init = k_init
+        self.components_init_scale = components_init_scale
+
+        # single TheraField object whose `apply` method is used for all grid cells
+        self.field = TheraField(hidden_dim, out_dim)
+
+        # infer output size of the hypernetwork from a sample pass through the field;
+        # key doesnt matter as field params are only used for size inference
+        sample_params = self.field.init(jax.random.PRNGKey(0),
+            jnp.zeros((2,)), 0., 0., jnp.zeros((2, hidden_dim)))
+        sample_params_flat, tree_def = jax.tree_util.tree_flatten(sample_params)
+        param_shapes = [p.shape for p in sample_params_flat]
+
+        self.hypernet = Hypernetwork(backbone, tail, param_shapes, tree_def)
+
+    def init(self, key, sample_source) -> PyTree:
+        keys = jax.random.split(key, 2)
+        sample_coords = jnp.zeros(sample_source.shape[:-1] + (2,))
+        params = unfreeze(self.hypernet.init(keys[0], sample_source, sample_coords))
+
+        params['params']['k'] = jnp.array(self.k_init)
+        params['params']['components'] = \
+            linear_up(self.components_init_scale)(keys[1], (2, self.hidden_dim))
+
+        return freeze(params)
+
+    def apply_encoder(self, params: PyTree, source: ArrayLike, **kwargs) -> Array:
+        """
+        Performs a forward pass through the hypernetwork to obtain an encoding.
+        """
+        return self.hypernet.apply(
+            params, source, method=self.hypernet.get_encoding, **kwargs)
+
+    def apply_decoder(
+        self,
+        params: PyTree,
+        encoding: ArrayLike,
+        coords: ArrayLike,
+        t: ArrayLike,
+        return_jac: bool = False
+    ) -> Array | tuple[Array, Array]:
+        """
+        Performs a forward prediction through a grid of HxW Thera fields,
+        informed by `encoding`, at spatial and temporal coordinates
+        `coords` and `t`, respectively.
+        args:
+            params: Field parameters, shape (B, H, W, N)
+            encoding: Encoding tensor, shape (B, H, W, C)
+            coords: Spatial coordinates in [-0.5, 0.5], shape (B, H, W, 2)
+            t: Temporal coordinates, shape (B, 1)
+        """
+        phi_params: PyTree = self.hypernet.apply(
+            params, encoding, coords, method=self.hypernet.get_params_at_coords)
+
+        # create local coordinate systems
+        source_grid = jnp.asarray(make_grid(encoding.shape[-3:-1]))
+        source_coords = jnp.tile(source_grid, (encoding.shape[0], 1, 1, 1))
+        interp_coords = interpolate_grid(coords, source_coords)
+        rel_coords = (coords - interp_coords)
+        rel_coords = rel_coords.at[..., 0].set(rel_coords[..., 0] * encoding.shape[-3])
+        rel_coords = rel_coords.at[..., 1].set(rel_coords[..., 1] * encoding.shape[-2])
+
+        # three maps over params, coords; one over t; dont map k and components
+        in_axes = [(0, 0, None, None, None), (0, 0, None, None, None), (0, 0, 0, None, None)]
+        apply_field = repeat_vmap(self.field.apply, in_axes)
+        out = apply_field(phi_params, rel_coords, t, params['params']['k'],
+            params['params']['components'])
+
+        if return_jac:
+            apply_jac = repeat_vmap(jax.jacrev(self.field.apply, argnums=1), in_axes)
+            jac = apply_jac(phi_params, rel_coords, jnp.zeros_like(t), params['params']['k'],
+                params['params']['components'])
+            return out, jac
+
+        return out
+
+    def apply(
+        self,
+        params: ArrayLike,
+        source: ArrayLike,
+        coords: ArrayLike,
+        t: ArrayLike,
+        return_jac: bool = False,
+        **kwargs
+    ) -> Array:
+        """
+        Performs a forward pass through the Thera model.
+        """
+        encoding = self.apply_encoder(params, source, **kwargs)
+        out = self.apply_decoder(params, encoding, coords, t, return_jac=return_jac)
+        return out
+
+
+def build_thera(
+    out_dim: int,
+    backbone: str,
+    size: str,
+    k_init: float = None,
+    components_init_scale: float = None
+):
+    """
+    Convenience function for building the three Thera sizes described in the paper.
+    """
+    hidden_dim = 32 if size == 'air' else 512
+
+    if backbone == 'edsr-baseline':
+        backbone_module = EDSR(None, num_blocks=16, num_feats=64)
+    elif backbone == 'rdn':
+        backbone_module = RDN()
+    else:
+        raise NotImplementedError(backbone)
+
+    tail_module = build_tail(size)
+
+    return Thera(hidden_dim, out_dim, backbone_module, tail_module, k_init, components_init_scale)

requirements.txt

@@ -0,0 +1,40 @@
+-f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+# torch-cpu is sufficient since we only use it for data loading
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+chex==0.1.7
+ConfigArgParse==1.7
+einops==0.6.1
+flax==0.6.10
+flaxmodels==0.1.3
+jax==0.4.11
+jaxlib==0.4.11+cuda11.cudnn86
+jaxtyping==0.2.20
+ml-dtypes==0.1.0
+numpy==1.24.1
+nvidia-cublas-cu11==11.11.3.6
+nvidia-cuda-cupti-cu11==11.8.87
+nvidia-cuda-nvcc-cu11==11.8.89
+nvidia-cuda-runtime-cu11==11.8.89
+nvidia-cudnn-cu11==8.9.2.26
+nvidia-cufft-cu11==10.9.0.58
+nvidia-cusolver-cu11==11.4.1.48
+nvidia-cusparse-cu11==11.7.5.86
+opt-einsum==3.3.0
+optax==0.2.0
+orbax-checkpoint==0.2.4
+scipy==1.10.1
+timm==0.9.6
+torch==2.0.1+cpu
+torchaudio==2.0.2+cpu
+torchmetrics==1.2.0
+torchvision==0.15.2+cpu
+tqdm==4.65.0
+transformers==4.46.3
+Pillow==10.0.0
+wandb
+
+# gradio
+gradio==4.44.1
+gradio_imageslider==0.0.20
+spaces

super_resolve.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+
+from argparse import ArgumentParser, Namespace
+import pickle
+
+import jax
+from jax import jit
+import jax.numpy as jnp
+import numpy as np
+from PIL import Image
+
+from model import build_thera
+from utils import make_grid, interpolate_grid
+
+MEAN = jnp.array([.4488, .4371, .4040])
+VAR = jnp.array([.25, .25, .25])
+PATCH_SIZE = 256
+
+
+def process_single(source, apply_encoder, apply_decoder, params, target_shape):
+    t = jnp.float32((target_shape[0] / source.shape[1])**-2)[None]
+    coords_nearest = jnp.asarray(make_grid(target_shape)[None])
+    source_up = interpolate_grid(coords_nearest, source[None])
+    source = jax.nn.standardize(source, mean=MEAN, variance=VAR)[None]
+
+    encoding = apply_encoder(params, source)
+    coords = jnp.asarray(make_grid(source_up.shape[1:3])[None])  # global sampling coords
+    out = jnp.full_like(source_up, jnp.nan, dtype=jnp.float32)
+
+    for h_min in range(0, coords.shape[1], PATCH_SIZE):
+        h_max = min(h_min + PATCH_SIZE, coords.shape[1])
+        for w_min in range(0, coords.shape[2], PATCH_SIZE):
+            # apply decoder with one patch of coordinates
+            w_max = min(w_min + PATCH_SIZE, coords.shape[2])
+            coords_patch = coords[:, h_min:h_max, w_min:w_max]
+            out_patch = apply_decoder(params, encoding, coords_patch, t)
+            out = out.at[:, h_min:h_max, w_min:w_max].set(out_patch)
+
+    out = out * jnp.sqrt(VAR)[None, None, None] + MEAN[None, None, None]
+    out += source_up
+    return out
+
+
+def process(source, model, params, target_shape, do_ensemble=True):
+    apply_encoder = jit(model.apply_encoder)
+    apply_decoder = jit(model.apply_decoder)
+
+    outs = []
+    for i_rot in range(4 if do_ensemble else 1):
+        source_ = jnp.rot90(source, k=i_rot, axes=(-3, -2))
+        target_shape_ = tuple(reversed(target_shape)) if i_rot % 2 else target_shape
+        out = process_single(source_, apply_encoder, apply_decoder, params, target_shape_)
+        outs.append(jnp.rot90(out, k=i_rot, axes=(-2, -3)))
+
+    out = jnp.stack(outs).mean(0).clip(0., 1.)
+    return jnp.rint(out[0] * 255).astype(jnp.uint8)
+
+
+def main(args: Namespace):
+    source = np.asarray(Image.open(args.in_file)) / 255.
+
+    if args.scale is not None:
+        if args.size is not None:
+            raise ValueError('Cannot specify both size and scale')
+        target_shape = (
+            round(source.shape[0] * args.scale),
+            round(source.shape[1] * args.scale),
+        )
+    elif args.size is not None:
+        target_shape = args.size
+    else:
+        raise ValueError('Must specify either size or scale')
+
+    with open(args.checkpoint, 'rb') as fh:
+        check = pickle.load(fh)
+        params, backbone, size = check['model'], check['backbone'], check['size']
+
+    model = build_thera(3, backbone, size)
+
+    out = process(source, model, params, target_shape, not args.no_ensemble)
+
+    Image.fromarray(np.asarray(out)).save(args.out_file)
+
+
+def parse_args() -> Namespace:
+    parser = ArgumentParser()
+    parser.add_argument('in_file')
+    parser.add_argument('out_file')
+    parser.add_argument('--scale', type=float, help='Scale factor for super-resolution')
+    parser.add_argument('--size', type=int, nargs=2,
+                        help='Target size (h, w), mutually exclusive with --scale')
+    parser.add_argument('--checkpoint', help='Path to checkpoint file')
+    parser.add_argument('--no-ensemble', action='store_true', help='Disable geo-ensemble')
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)

utils.py

@@ -0,0 +1,36 @@
+from functools import partial
+
+import jax
+import numpy as np
+
+
+def repeat_vmap(fun, in_axes=[0]):
+    for axes in in_axes:
+        fun = jax.vmap(fun, in_axes=axes)
+    return fun
+
+
+def make_grid(patch_size: int | tuple[int, int]):
+    if isinstance(patch_size, int):
+        patch_size = (patch_size, patch_size)
+    offset_h, offset_w = 1 / (2 * np.array(patch_size))
+    space_h = np.linspace(-0.5 + offset_h, 0.5 - offset_h, patch_size[0])
+    space_w = np.linspace(-0.5 + offset_w, 0.5 - offset_w, patch_size[1])
+    return np.stack(np.meshgrid(space_h, space_w, indexing='ij'), axis=-1)  # [h, w]
+
+
+def interpolate_grid(coords, grid, order=0):
+    """
+    args:
+        coords: Tensor of shape (B, H, W, 2) with coordinates in [-0.5, 0.5]
+        grid: Tensor of shape (B, H', W', C)
+    returns:
+        Tensor of shape (B, H, W, C) with interpolated values
+    """
+    # convert [-0.5, 0.5] -> [0, size], where pixel centers are expected at
+    # [-0.5 + 1 / (2*size), ..., 0.5 - 1 / (2*size)]
+    coords = coords.transpose((0, 3, 1, 2))
+    coords = coords.at[:, 0].set(coords[:, 0] * grid.shape[-3] + (grid.shape[-3] - 1) / 2)
+    coords = coords.at[:, 1].set(coords[:, 1] * grid.shape[-2] + (grid.shape[-2] - 1) / 2)
+    map_coordinates = partial(jax.scipy.ndimage.map_coordinates, order=order, mode='nearest')
+    return jax.vmap(jax.vmap(map_coordinates, in_axes=(2, None), out_axes=2))(grid, coords)