From 53c14883c67d491b10ca263693ca9485605193f6 Mon Sep 17 00:00:00 2001
From: Matt McCormick <matt.mccormick@kitware.com>
Date: Tue, 28 Nov 2023 17:14:37 -0500
Subject: [PATCH] feat(mesh-io): add mesh-io-emscripten bindgen output

---
 .../itkwasm-mesh-io-emscripten/README.md      | 23 ++++++
 .../itkwasm_mesh_io_emscripten/__init__.py    | 26 +++++++
 .../itkwasm_mesh_io_emscripten/_version.py    |  1 +
 .../byu_read_mesh_async.py                    | 60 +++++++++++++++
 .../byu_write_mesh_async.py                   | 73 +++++++++++++++++++
 .../free_surfer_ascii_read_mesh_async.py      | 60 +++++++++++++++
 .../free_surfer_ascii_write_mesh_async.py     | 73 +++++++++++++++++++
 .../free_surfer_binary_read_mesh_async.py     | 60 +++++++++++++++
 .../free_surfer_binary_write_mesh_async.py    | 73 +++++++++++++++++++
 .../itkwasm_mesh_io_emscripten/js_package.py  |  8 ++
 .../obj_read_mesh_async.py                    | 60 +++++++++++++++
 .../obj_write_mesh_async.py                   | 73 +++++++++++++++++++
 .../off_read_mesh_async.py                    | 60 +++++++++++++++
 .../off_write_mesh_async.py                   | 73 +++++++++++++++++++
 .../stl_read_mesh_async.py                    | 60 +++++++++++++++
 .../stl_write_mesh_async.py                   | 73 +++++++++++++++++++
 .../swc_read_mesh_async.py                    | 60 +++++++++++++++
 .../swc_write_mesh_async.py                   | 73 +++++++++++++++++++
 .../vtk_poly_data_read_mesh_async.py          | 60 +++++++++++++++
 .../vtk_poly_data_write_mesh_async.py         | 73 +++++++++++++++++++
 .../wasm_read_mesh_async.py                   | 60 +++++++++++++++
 .../wasm_write_mesh_async.py                  | 73 +++++++++++++++++++
 .../wasm_zstd_read_mesh_async.py              | 60 +++++++++++++++
 .../wasm_zstd_write_mesh_async.py             | 73 +++++++++++++++++++
 .../wasm_ztd_read_mesh_async.py               | 60 +++++++++++++++
 .../wasm_ztd_write_mesh_async.py              | 73 +++++++++++++++++++
 .../itkwasm-mesh-io-emscripten/pyproject.toml | 73 +++++++++++++++++++
 .../test/__init__.py                          |  0
 .../test/fixtures.py                          | 28 +++++++
 .../test/test_itkwasm_mesh_io.py              | 20 +++++
 .../python/itkwasm-mesh-io-wasi/.gitignore    |  1 +
 31 files changed, 1643 insertions(+)
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/README.md
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/__init__.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/_version.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/js_package.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_read_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_write_mesh_async.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/pyproject.toml
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/__init__.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/fixtures.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/test_itkwasm_mesh_io.py
 create mode 100644 packages/mesh-io/python/itkwasm-mesh-io-wasi/.gitignore

diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/README.md b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/README.md
new file mode 100644
index 000000000..ad8bf8aa9
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/README.md
@@ -0,0 +1,23 @@
+# itkwasm-mesh-io-emscripten
+
+[![PyPI version](https://badge.fury.io/py/itkwasm-mesh-io-emscripten.svg)](https://badge.fury.io/py/itkwasm-mesh-io-emscripten)
+
+Input and output for scientific and medical image file formats. Emscripten implementation.
+
+This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please use the [`itkwasm-mesh-io`](https://pypi.org/project/itkwasm-mesh-io/) instead.
+
+
+## Installation
+
+```sh
+import micropip
+await micropip.install('itkwasm-mesh-io-emscripten')
+```
+
+## Development
+
+```sh
+pip install hatch
+hatch run download-pyodide
+hatch run test
+```
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/__init__.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/__init__.py
new file mode 100644
index 000000000..ae7c1e164
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/__init__.py
@@ -0,0 +1,26 @@
+# Generated file. To retain edits, remove this comment.
+
+"""itkwasm-mesh-io-emscripten: Input and output for scientific and medical image file formats. Emscripten implementation."""
+
+from .byu_read_mesh_async import byu_read_mesh_async
+from .byu_write_mesh_async import byu_write_mesh_async
+from .free_surfer_ascii_read_mesh_async import free_surfer_ascii_read_mesh_async
+from .free_surfer_ascii_write_mesh_async import free_surfer_ascii_write_mesh_async
+from .free_surfer_binary_read_mesh_async import free_surfer_binary_read_mesh_async
+from .free_surfer_binary_write_mesh_async import free_surfer_binary_write_mesh_async
+from .obj_read_mesh_async import obj_read_mesh_async
+from .obj_write_mesh_async import obj_write_mesh_async
+from .off_read_mesh_async import off_read_mesh_async
+from .off_write_mesh_async import off_write_mesh_async
+from .stl_read_mesh_async import stl_read_mesh_async
+from .stl_write_mesh_async import stl_write_mesh_async
+from .swc_read_mesh_async import swc_read_mesh_async
+from .swc_write_mesh_async import swc_write_mesh_async
+from .vtk_poly_data_read_mesh_async import vtk_poly_data_read_mesh_async
+from .vtk_poly_data_write_mesh_async import vtk_poly_data_write_mesh_async
+from .wasm_read_mesh_async import wasm_read_mesh_async
+from .wasm_write_mesh_async import wasm_write_mesh_async
+from .wasm_zstd_read_mesh_async import wasm_zstd_read_mesh_async
+from .wasm_zstd_write_mesh_async import wasm_zstd_write_mesh_async
+
+from ._version import __version__
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/_version.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/_version.py
new file mode 100644
index 000000000..3dc1f76bc
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/_version.py
@@ -0,0 +1 @@
+__version__ = "0.1.0"
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_read_mesh_async.py
new file mode 100644
index 000000000..27144ebad
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def byu_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.byuReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_write_mesh_async.py
new file mode 100644
index 000000000..367a88bf7
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/byu_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def byu_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.byuWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_read_mesh_async.py
new file mode 100644
index 000000000..ab9a6d548
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def free_surfer_ascii_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.freeSurferAsciiReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_write_mesh_async.py
new file mode 100644
index 000000000..3a48b5d97
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_ascii_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def free_surfer_ascii_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.freeSurferAsciiWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_read_mesh_async.py
new file mode 100644
index 000000000..01fe90707
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def free_surfer_binary_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.freeSurferBinaryReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_write_mesh_async.py
new file mode 100644
index 000000000..a776ab238
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/free_surfer_binary_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def free_surfer_binary_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.freeSurferBinaryWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/js_package.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/js_package.py
new file mode 100644
index 000000000..4bebadc47
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/js_package.py
@@ -0,0 +1,8 @@
+# Generated file. To retain edits, remove this comment.
+
+from itkwasm.pyodide import JsPackageConfig, JsPackage
+
+from ._version import __version__
+default_js_module = """data:text/javascript;base64,var Mt=Object.defineProperty;var Pt=(A,e)=>{for(var t in e)Mt(A,t,{get:e[t],enumerable:!0})};var xt="1.0.0-b.156",eA=xt;var Wt={pipelineWorkerUrl:`https://cdn.jsdelivr.net/npm/itk-wasm@${eA}/dist/core/web-workers/bundles/pipeline.min.worker.js`,imageIOUrl:`https://cdn.jsdelivr.net/npm/itk-image-io@${eA}`,meshIOUrl:`https://cdn.jsdelivr.net/npm/itk-mesh-io@${eA}`,pipelinesUrl:`https://cdn.jsdelivr.net/npm/itk-wasm@${eA}/dist/pipelines`},q=Wt;var Gt={TextFile:"InterfaceTextFile",BinaryFile:"InterfaceBinaryFile",TextStream:"InterfaceTextStream",BinaryStream:"InterfaceBinaryStream",Image:"InterfaceImage",Mesh:"InterfaceMesh",PolyData:"InterfacePolyData",JsonCompatible:"InterfaceJsonCompatible"},B=Gt;var Tt={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},O=Tt;var Lt={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},J=Lt;var Jt={Text:"Text",Binary:"Binary",Image:"Image",Mesh:"Mesh"},U=Jt;function Ht(A,e){let t=null;switch(A){case O.UInt8:{t=new Uint8Array(e);break}case O.Int8:{t=new Int8Array(e);break}case O.UInt16:{t=new Uint16Array(e);break}case O.Int16:{t=new Int16Array(e);break}case O.UInt32:{t=new Uint32Array(e);break}case O.Int32:{t=new Int32Array(e);break}case O.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case O.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case J.Float32:{t=new Float32Array(e);break}case J.Float64:{t=new Float64Array(e);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var F=Ht;var Yt=typeof globalThis.SharedArrayBuffer<"u";function qt(A){if(A==null)return[];let e=[];for(let t=0;t<A.length;t++){let r=Kt(A[t]);r!==null&&e.push(r)}return e}function Kt(A){if(A==null)return null;let e=null;return A.buffer!==void 0?e=A.buffer:A.byteLength!==void 0&&(e=A),Yt&&e instanceof SharedArrayBuffer?null:e}var Re=qt;function tA(A,e){return function(){return A.apply(e,arguments)}}var{toString:vt}=Object.prototype,{getPrototypeOf:NA}=Object,fA=(A=>e=>{let t=vt.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),P=A=>(A=A.toLowerCase(),e=>fA(e)===A),pA=A=>e=>typeof e===A,{isArray:K}=Array,rA=pA("undefined");function jt(A){return A!==null&&!rA(A)&&A.constructor!==null&&!rA(A.constructor)&&M(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var Oe=P("ArrayBuffer");function _t(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&Oe(A.buffer),e}var zt=pA("string"),M=pA("function"),Ue=pA("number"),cA=A=>A!==null&&typeof A=="object",Vt=A=>A===!0||A===!1,uA=A=>{if(fA(A)!=="object")return!1;let e=NA(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},Zt=P("Date"),Xt=P("File"),$t=P("Blob"),Ar=P("FileList"),er=A=>cA(A)&&M(A.pipe),tr=A=>{let e;return A&&(typeof FormData=="function"&&A instanceof FormData||M(A.append)&&((e=fA(A))==="formdata"||e==="object"&&M(A.toString)&&A.toString()==="[object FormData]"))},rr=P("URLSearchParams"),ir=A=>A.trim?A.trim():A.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function iA(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let r,n;if(typeof A!="object"&&(A=[A]),K(A))for(r=0,n=A.length;r<n;r++)e.call(null,A[r],r,A);else{let o=t?Object.getOwnPropertyNames(A):Object.keys(A),i=o.length,l;for(r=0;r<i;r++)l=o[r],e.call(null,A[l],l,A)}}function Ne(A,e){e=e.toLowerCase();let t=Object.keys(A),r=t.length,n;for(;r-- >0;)if(n=t[r],e===n.toLowerCase())return n;return null}var Me=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,Pe=A=>!rA(A)&&A!==Me;function UA(){let{caseless:A}=Pe(this)&&this||{},e={},t=(r,n)=>{let o=A&&Ne(e,n)||n;uA(e[o])&&uA(r)?e[o]=UA(e[o],r):uA(r)?e[o]=UA({},r):K(r)?e[o]=r.slice():e[o]=r};for(let r=0,n=arguments.length;r<n;r++)arguments[r]&&iA(arguments[r],t);return e}var nr=(A,e,t,{allOwnKeys:r}={})=>(iA(e,(n,o)=>{t&&M(n)?A[o]=tA(n,t):A[o]=n},{allOwnKeys:r}),A),or=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),ar=(A,e,t,r)=>{A.prototype=Object.create(e.prototype,r),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},sr=(A,e,t,r)=>{let n,o,i,l={};if(e=e||{},A==null)return e;do{for(n=Object.getOwnPropertyNames(A),o=n.length;o-- >0;)i=n[o],(!r||r(i,A,e))&&!l[i]&&(e[i]=A[i],l[i]=!0);A=t!==!1&&NA(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},Ir=(A,e,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=e.length;let r=A.indexOf(e,t);return r!==-1&&r===t},lr=A=>{if(!A)return null;if(K(A))return A;let e=A.length;if(!Ue(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},gr=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&NA(Uint8Array)),ur=(A,e)=>{let r=(A&&A[Symbol.iterator]).call(A),n;for(;(n=r.next())&&!n.done;){let o=n.value;e.call(A,o[0],o[1])}},fr=(A,e)=>{let t,r=[];for(;(t=A.exec(e))!==null;)r.push(t);return r},pr=P("HTMLFormElement"),cr=A=>A.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(t,r,n){return r.toUpperCase()+n}),Se=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),Br=P("RegExp"),xe=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),r={};iA(t,(n,o)=>{let i;(i=e(n,o,A))!==!1&&(r[o]=i||n)}),Object.defineProperties(A,r)},Cr=A=>{xe(A,(e,t)=>{if(M(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let r=A[t];if(M(r)){if(e.enumerable=!1,"writable"in e){e.writable=!1;return}e.set||(e.set=()=>{throw Error("Can not rewrite read-only method '"+t+"'")})}})},mr=(A,e)=>{let t={},r=n=>{n.forEach(o=>{t[o]=!0})};return K(A)?r(A):r(String(A).split(e)),t},dr=()=>{},Er=(A,e)=>(A=+A,Number.isFinite(A)?A:e),OA="abcdefghijklmnopqrstuvwxyz",ke="0123456789",We={DIGIT:ke,ALPHA:OA,ALPHA_DIGIT:OA+OA.toUpperCase()+ke},Qr=(A=16,e=We.ALPHA_DIGIT)=>{let t="",{length:r}=e;for(;A--;)t+=e[Math.random()*r|0];return t};function hr(A){return!!(A&&M(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var yr=A=>{let e=new Array(10),t=(r,n)=>{if(cA(r)){if(e.indexOf(r)>=0)return;if(!("toJSON"in r)){e[n]=r;let o=K(r)?[]:{};return iA(r,(i,l)=>{let c=t(i,n+1);!rA(c)&&(o[l]=c)}),e[n]=void 0,o}}return r};return t(A,0)},wr=P("AsyncFunction"),Dr=A=>A&&(cA(A)||M(A))&&M(A.then)&&M(A.catch),p={isArray:K,isArrayBuffer:Oe,isBuffer:jt,isFormData:tr,isArrayBufferView:_t,isString:zt,isNumber:Ue,isBoolean:Vt,isObject:cA,isPlainObject:uA,isUndefined:rA,isDate:Zt,isFile:Xt,isBlob:$t,isRegExp:Br,isFunction:M,isStream:er,isURLSearchParams:rr,isTypedArray:gr,isFileList:Ar,forEach:iA,merge:UA,extend:nr,trim:ir,stripBOM:or,inherits:ar,toFlatObject:sr,kindOf:fA,kindOfTest:P,endsWith:Ir,toArray:lr,forEachEntry:ur,matchAll:fr,isHTMLForm:pr,hasOwnProperty:Se,hasOwnProp:Se,reduceDescriptors:xe,freezeMethods:Cr,toObjectSet:mr,toCamelCase:cr,noop:dr,toFiniteNumber:Er,findKey:Ne,global:Me,isContextDefined:Pe,ALPHABET:We,generateString:Qr,isSpecCompliantForm:hr,toJSONObject:yr,isAsyncFn:wr,isThenable:Dr};function v(A,e,t,r,n){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",e&&(this.code=e),t&&(this.config=t),r&&(this.request=r),n&&(this.response=n)}p.inherits(v,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:p.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var Ge=v.prototype,Te={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{Te[A]={value:A}});Object.defineProperties(v,Te);Object.defineProperty(Ge,"isAxiosError",{value:!0});v.from=(A,e,t,r,n,o)=>{let i=Object.create(Ge);return p.toFlatObject(A,i,function(c){return c!==Error.prototype},l=>l!=="isAxiosError"),v.call(i,A.message,e,t,r,n),i.cause=A,i.name=A.name,o&&Object.assign(i,o),i};var h=v;var BA=null;function MA(A){return p.isPlainObject(A)||p.isArray(A)}function Je(A){return p.endsWith(A,"[]")?A.slice(0,-2):A}function Le(A,e,t){return A?A.concat(e).map(function(n,o){return n=Je(n),!t&&o?"["+n+"]":n}).join(t?".":""):e}function br(A){return p.isArray(A)&&!A.some(MA)}var Fr=p.toFlatObject(p,{},null,function(e){return/^is[A-Z]/.test(e)});function Rr(A,e,t){if(!p.isObject(A))throw new TypeError("target must be an object");e=e||new(BA||FormData),t=p.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(C,m){return!p.isUndefined(m[C])});let r=t.metaTokens,n=t.visitor||g,o=t.dots,i=t.indexes,c=(t.Blob||typeof Blob<"u"&&Blob)&&p.isSpecCompliantForm(e);if(!p.isFunction(n))throw new TypeError("visitor must be a function");function I(s){if(s===null)return"";if(p.isDate(s))return s.toISOString();if(!c&&p.isBlob(s))throw new h("Blob is not supported. Use a Buffer instead.");return p.isArrayBuffer(s)||p.isTypedArray(s)?c&&typeof Blob=="function"?new Blob([s]):Buffer.from(s):s}function g(s,C,m){let w=s;if(s&&!m&&typeof s=="object"){if(p.endsWith(C,"{}"))C=r?C:C.slice(0,-2),s=JSON.stringify(s);else if(p.isArray(s)&&br(s)||(p.isFileList(s)||p.endsWith(C,"[]"))&&(w=p.toArray(s)))return C=Je(C),w.forEach(function(D,kA){!(p.isUndefined(D)||D===null)&&e.append(i===!0?Le([C],kA,o):i===null?C:C+"[]",I(D))}),!1}return MA(s)?!0:(e.append(Le(m,C,o),I(s)),!1)}let u=[],f=Object.assign(Fr,{defaultVisitor:g,convertValue:I,isVisitable:MA});function a(s,C){if(!p.isUndefined(s)){if(u.indexOf(s)!==-1)throw Error("Circular reference detected in "+C.join("."));u.push(s),p.forEach(s,function(w,y){(!(p.isUndefined(w)||w===null)&&n.call(e,w,p.isString(y)?y.trim():y,C,f))===!0&&a(w,C?C.concat(y):[y])}),u.pop()}}if(!p.isObject(A))throw new TypeError("data must be an object");return a(A),e}var W=Rr;function He(A){let e={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+","%00":"\0"};return encodeURIComponent(A).replace(/[!'()~]|%20|%00/g,function(r){return e[r]})}function Ye(A,e){this._pairs=[],A&&W(A,this,e)}var qe=Ye.prototype;qe.append=function(e,t){this._pairs.push([e,t])};qe.toString=function(e){let t=e?function(r){return e.call(this,r,He)}:He;return this._pairs.map(function(n){return t(n[0])+"="+t(n[1])},"").join("&")};var CA=Ye;function Sr(A){return encodeURIComponent(A).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}function nA(A,e,t){if(!e)return A;let r=t&&t.encode||Sr,n=t&&t.serialize,o;if(n?o=n(e,t):o=p.isURLSearchParams(e)?e.toString():new CA(e,t).toString(r),o){let i=A.indexOf("#");i!==-1&&(A=A.slice(0,i)),A+=(A.indexOf("?")===-1?"?":"&")+o}return A}var PA=class{constructor(){this.handlers=[]}use(e,t,r){return this.handlers.push({fulfilled:e,rejected:t,synchronous:r?r.synchronous:!1,runWhen:r?r.runWhen:null}),this.handlers.length-1}eject(e){this.handlers[e]&&(this.handlers[e]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(e){p.forEach(this.handlers,function(r){r!==null&&e(r)})}},xA=PA;var mA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var Ke=typeof URLSearchParams<"u"?URLSearchParams:CA;var ve=typeof FormData<"u"?FormData:null;var je=typeof Blob<"u"?Blob:null;var _e={isBrowser:!0,classes:{URLSearchParams:Ke,FormData:ve,Blob:je},protocols:["http","https","file","blob","url","data"]};var WA={};Pt(WA,{hasBrowserEnv:()=>ze,hasStandardBrowserEnv:()=>kr,hasStandardBrowserWebWorkerEnv:()=>Or});var ze=typeof window<"u"&&typeof document<"u",kr=(A=>ze&&["ReactNative","NativeScript","NS"].indexOf(A)<0)(typeof navigator<"u"&&navigator.product),Or=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function";var S={...WA,..._e};function GA(A,e){return W(A,new S.classes.URLSearchParams,Object.assign({visitor:function(t,r,n,o){return S.isNode&&p.isBuffer(t)?(this.append(r,t.toString("base64")),!1):o.defaultVisitor.apply(this,arguments)}},e))}function Ur(A){return p.matchAll(/\w+|\[(\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function Nr(A){let e={},t=Object.keys(A),r,n=t.length,o;for(r=0;r<n;r++)o=t[r],e[o]=A[o];return e}function Mr(A){function e(t,r,n,o){let i=t[o++],l=Number.isFinite(+i),c=o>=t.length;return i=!i&&p.isArray(n)?n.length:i,c?(p.hasOwnProp(n,i)?n[i]=[n[i],r]:n[i]=r,!l):((!n[i]||!p.isObject(n[i]))&&(n[i]=[]),e(t,r,n[i],o)&&p.isArray(n[i])&&(n[i]=Nr(n[i])),!l)}if(p.isFormData(A)&&p.isFunction(A.entries)){let t={};return p.forEachEntry(A,(r,n)=>{e(Ur(r),n,t,0)}),t}return null}var dA=Mr;function Pr(A,e,t){if(p.isString(A))try{return(e||JSON.parse)(A),p.trim(A)}catch(r){if(r.name!=="SyntaxError")throw r}return(t||JSON.stringify)(A)}var TA={transitional:mA,adapter:["xhr","http"],transformRequest:[function(e,t){let r=t.getContentType()||"",n=r.indexOf("application/json")>-1,o=p.isObject(e);if(o&&p.isHTMLForm(e)&&(e=new FormData(e)),p.isFormData(e))return n&&n?JSON.stringify(dA(e)):e;if(p.isArrayBuffer(e)||p.isBuffer(e)||p.isStream(e)||p.isFile(e)||p.isBlob(e))return e;if(p.isArrayBufferView(e))return e.buffer;if(p.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let l;if(o){if(r.indexOf("application/x-www-form-urlencoded")>-1)return GA(e,this.formSerializer).toString();if((l=p.isFileList(e))||r.indexOf("multipart/form-data")>-1){let c=this.env&&this.env.FormData;return W(l?{"files[]":e}:e,c&&new c,this.formSerializer)}}return o||n?(t.setContentType("application/json",!1),Pr(e)):e}],transformResponse:[function(e){let t=this.transitional||TA.transitional,r=t&&t.forcedJSONParsing,n=this.responseType==="json";if(e&&p.isString(e)&&(r&&!this.responseType||n)){let i=!(t&&t.silentJSONParsing)&&n;try{return JSON.parse(e)}catch(l){if(i)throw l.name==="SyntaxError"?h.from(l,h.ERR_BAD_RESPONSE,this,null,this.response):l}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:S.classes.FormData,Blob:S.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};p.forEach(["delete","get","head","post","put","patch"],A=>{TA.headers[A]={}});var j=TA;var xr=p.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),Ve=A=>{let e={},t,r,n;return A&&A.split(`
`).forEach(function(i){n=i.indexOf(":"),t=i.substring(0,n).trim().toLowerCase(),r=i.substring(n+1).trim(),!(!t||e[t]&&xr[t])&&(t==="set-cookie"?e[t]?e[t].push(r):e[t]=[r]:e[t]=e[t]?e[t]+", "+r:r)}),e};var Ze=Symbol("internals");function oA(A){return A&&String(A).trim().toLowerCase()}function EA(A){return A===!1||A==null?A:p.isArray(A)?A.map(EA):String(A)}function Wr(A){let e=Object.create(null),t=/([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g,r;for(;r=t.exec(A);)e[r[1]]=r[2];return e}var Gr=A=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(A.trim());function LA(A,e,t,r,n){if(p.isFunction(r))return r.call(this,e,t);if(n&&(e=t),!!p.isString(e)){if(p.isString(r))return e.indexOf(r)!==-1;if(p.isRegExp(r))return r.test(e)}}function Tr(A){return A.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(e,t,r)=>t.toUpperCase()+r)}function Lr(A,e){let t=p.toCamelCase(" "+e);["get","set","has"].forEach(r=>{Object.defineProperty(A,r+t,{value:function(n,o,i){return this[r].call(this,e,n,o,i)},configurable:!0})})}var _=class{constructor(e){e&&this.set(e)}set(e,t,r){let n=this;function o(l,c,I){let g=oA(c);if(!g)throw new Error("header name must be a non-empty string");let u=p.findKey(n,g);(!u||n[u]===void 0||I===!0||I===void 0&&n[u]!==!1)&&(n[u||c]=EA(l))}let i=(l,c)=>p.forEach(l,(I,g)=>o(I,g,c));return p.isPlainObject(e)||e instanceof this.constructor?i(e,t):p.isString(e)&&(e=e.trim())&&!Gr(e)?i(Ve(e),t):e!=null&&o(t,e,r),this}get(e,t){if(e=oA(e),e){let r=p.findKey(this,e);if(r){let n=this[r];if(!t)return n;if(t===!0)return Wr(n);if(p.isFunction(t))return t.call(this,n,r);if(p.isRegExp(t))return t.exec(n);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=oA(e),e){let r=p.findKey(this,e);return!!(r&&this[r]!==void 0&&(!t||LA(this,this[r],r,t)))}return!1}delete(e,t){let r=this,n=!1;function o(i){if(i=oA(i),i){let l=p.findKey(r,i);l&&(!t||LA(r,r[l],l,t))&&(delete r[l],n=!0)}}return p.isArray(e)?e.forEach(o):o(e),n}clear(e){let t=Object.keys(this),r=t.length,n=!1;for(;r--;){let o=t[r];(!e||LA(this,this[o],o,e,!0))&&(delete this[o],n=!0)}return n}normalize(e){let t=this,r={};return p.forEach(this,(n,o)=>{let i=p.findKey(r,o);if(i){t[i]=EA(n),delete t[o];return}let l=e?Tr(o):String(o).trim();l!==o&&delete t[o],t[l]=EA(n),r[l]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return p.forEach(this,(r,n)=>{r!=null&&r!==!1&&(t[n]=e&&p.isArray(r)?r.join(", "):r)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([e,t])=>e+": "+t).join(`
`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(e){return e instanceof this?e:new this(e)}static concat(e,...t){let r=new this(e);return t.forEach(n=>r.set(n)),r}static accessor(e){let r=(this[Ze]=this[Ze]={accessors:{}}).accessors,n=this.prototype;function o(i){let l=oA(i);r[l]||(Lr(n,i),r[l]=!0)}return p.isArray(e)?e.forEach(o):o(e),this}};_.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);p.reduceDescriptors(_.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(r){this[t]=r}}});p.freezeMethods(_);var k=_;function aA(A,e){let t=this||j,r=e||t,n=k.from(r.headers),o=r.data;return p.forEach(A,function(l){o=l.call(t,o,n.normalize(),e?e.status:void 0)}),n.normalize(),o}function sA(A){return!!(A&&A.__CANCEL__)}function Xe(A,e,t){h.call(this,A??"canceled",h.ERR_CANCELED,e,t),this.name="CanceledError"}p.inherits(Xe,h,{__CANCEL__:!0});var G=Xe;function JA(A,e,t){let r=t.config.validateStatus;!t.status||!r||r(t.status)?A(t):e(new h("Request failed with status code "+t.status,[h.ERR_BAD_REQUEST,h.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var $e=S.hasStandardBrowserEnv?{write(A,e,t,r,n,o){let i=[A+"="+encodeURIComponent(e)];p.isNumber(t)&&i.push("expires="+new Date(t).toGMTString()),p.isString(r)&&i.push("path="+r),p.isString(n)&&i.push("domain="+n),o===!0&&i.push("secure"),document.cookie=i.join("; ")},read(A){let e=document.cookie.match(new RegExp("(^|;\\s*)("+A+")=([^;]*)"));return e?decodeURIComponent(e[3]):null},remove(A){this.write(A,"",Date.now()-864e5)}}:{write(){},read(){return null},remove(){}};function HA(A){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(A)}function YA(A,e){return e?A.replace(/\/+$/,"")+"/"+e.replace(/^\/+/,""):A}function IA(A,e){return A&&!HA(e)?YA(A,e):e}var At=S.hasStandardBrowserEnv?function(){let e=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),r;function n(o){let i=o;return e&&(t.setAttribute("href",i),i=t.href),t.setAttribute("href",i),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\?/,""):"",hash:t.hash?t.hash.replace(/^#/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return r=n(window.location.href),function(i){let l=p.isString(i)?n(i):i;return l.protocol===r.protocol&&l.host===r.host}}():function(){return function(){return!0}}();function qA(A){let e=/^([-+\w]{1,25})(:?\/\/|:)/.exec(A);return e&&e[1]||""}function Jr(A,e){A=A||10;let t=new Array(A),r=new Array(A),n=0,o=0,i;return e=e!==void 0?e:1e3,function(c){let I=Date.now(),g=r[o];i||(i=I),t[n]=c,r[n]=I;let u=o,f=0;for(;u!==n;)f+=t[u++],u=u%A;if(n=(n+1)%A,n===o&&(o=(o+1)%A),I-i<e)return;let a=g&&I-g;return a?Math.round(f*1e3/a):void 0}}var et=Jr;function tt(A,e){let t=0,r=et(50,250);return n=>{let o=n.loaded,i=n.lengthComputable?n.total:void 0,l=o-t,c=r(l),I=o<=i;t=o;let g={loaded:o,total:i,progress:i?o/i:void 0,bytes:l,rate:c||void 0,estimated:c&&i&&I?(i-o)/c:void 0,event:n};g[e?"download":"upload"]=!0,A(g)}}var Hr=typeof XMLHttpRequest<"u",rt=Hr&&function(A){return new Promise(function(t,r){let n=A.data,o=k.from(A.headers).normalize(),{responseType:i,withXSRFToken:l}=A,c;function I(){A.cancelToken&&A.cancelToken.unsubscribe(c),A.signal&&A.signal.removeEventListener("abort",c)}let g;if(p.isFormData(n)){if(S.hasStandardBrowserEnv||S.hasStandardBrowserWebWorkerEnv)o.setContentType(!1);else if((g=o.getContentType())!==!1){let[C,...m]=g?g.split(";").map(w=>w.trim()).filter(Boolean):[];o.setContentType([C||"multipart/form-data",...m].join("; "))}}let u=new XMLHttpRequest;if(A.auth){let C=A.auth.username||"",m=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";o.set("Authorization","Basic "+btoa(C+":"+m))}let f=IA(A.baseURL,A.url);u.open(A.method.toUpperCase(),nA(f,A.params,A.paramsSerializer),!0),u.timeout=A.timeout;function a(){if(!u)return;let C=k.from("getAllResponseHeaders"in u&&u.getAllResponseHeaders()),w={data:!i||i==="text"||i==="json"?u.responseText:u.response,status:u.status,statusText:u.statusText,headers:C,config:A,request:u};JA(function(D){t(D),I()},function(D){r(D),I()},w),u=null}if("onloadend"in u?u.onloadend=a:u.onreadystatechange=function(){!u||u.readyState!==4||u.status===0&&!(u.responseURL&&u.responseURL.indexOf("file:")===0)||setTimeout(a)},u.onabort=function(){u&&(r(new h("Request aborted",h.ECONNABORTED,A,u)),u=null)},u.onerror=function(){r(new h("Network Error",h.ERR_NETWORK,A,u)),u=null},u.ontimeout=function(){let m=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",w=A.transitional||mA;A.timeoutErrorMessage&&(m=A.timeoutErrorMessage),r(new h(m,w.clarifyTimeoutError?h.ETIMEDOUT:h.ECONNABORTED,A,u)),u=null},S.hasStandardBrowserEnv&&(l&&p.isFunction(l)&&(l=l(A)),l||l!==!1&&At(f))){let C=A.xsrfHeaderName&&A.xsrfCookieName&&$e.read(A.xsrfCookieName);C&&o.set(A.xsrfHeaderName,C)}n===void 0&&o.setContentType(null),"setRequestHeader"in u&&p.forEach(o.toJSON(),function(m,w){u.setRequestHeader(w,m)}),p.isUndefined(A.withCredentials)||(u.withCredentials=!!A.withCredentials),i&&i!=="json"&&(u.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&u.addEventListener("progress",tt(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&u.upload&&u.upload.addEventListener("progress",tt(A.onUploadProgress)),(A.cancelToken||A.signal)&&(c=C=>{u&&(r(!C||C.type?new G(null,A,u):C),u.abort(),u=null)},A.cancelToken&&A.cancelToken.subscribe(c),A.signal&&(A.signal.aborted?c():A.signal.addEventListener("abort",c)));let s=qA(f);if(s&&S.protocols.indexOf(s)===-1){r(new h("Unsupported protocol "+s+":",h.ERR_BAD_REQUEST,A));return}u.send(n||null)})};var KA={http:BA,xhr:rt};p.forEach(KA,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var it=A=>`- ${A}`,Yr=A=>p.isFunction(A)||A===null||A===!1,QA={getAdapter:A=>{A=p.isArray(A)?A:[A];let{length:e}=A,t,r,n={};for(let o=0;o<e;o++){t=A[o];let i;if(r=t,!Yr(t)&&(r=KA[(i=String(t)).toLowerCase()],r===void 0))throw new h(`Unknown adapter '${i}'`);if(r)break;n[i||"#"+o]=r}if(!r){let o=Object.entries(n).map(([l,c])=>`adapter ${l} `+(c===!1?"is not supported by the environment":"is not available in the build")),i=e?o.length>1?`since :
`+o.map(it).join(`
`):" "+it(o[0]):"as no adapter specified";throw new h("There is no suitable adapter to dispatch the request "+i,"ERR_NOT_SUPPORT")}return r},adapters:KA};function vA(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new G(null,A)}function hA(A){return vA(A),A.headers=k.from(A.headers),A.data=aA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),QA.getAdapter(A.adapter||j.adapter)(A).then(function(r){return vA(A),r.data=aA.call(A,A.transformResponse,r),r.headers=k.from(r.headers),r},function(r){return sA(r)||(vA(A),r&&r.response&&(r.response.data=aA.call(A,A.transformResponse,r.response),r.response.headers=k.from(r.response.headers))),Promise.reject(r)})}var nt=A=>A instanceof k?A.toJSON():A;function x(A,e){e=e||{};let t={};function r(I,g,u){return p.isPlainObject(I)&&p.isPlainObject(g)?p.merge.call({caseless:u},I,g):p.isPlainObject(g)?p.merge({},g):p.isArray(g)?g.slice():g}function n(I,g,u){if(p.isUndefined(g)){if(!p.isUndefined(I))return r(void 0,I,u)}else return r(I,g,u)}function o(I,g){if(!p.isUndefined(g))return r(void 0,g)}function i(I,g){if(p.isUndefined(g)){if(!p.isUndefined(I))return r(void 0,I)}else return r(void 0,g)}function l(I,g,u){if(u in e)return r(I,g);if(u in A)return r(void 0,I)}let c={url:o,method:o,data:o,baseURL:i,transformRequest:i,transformResponse:i,paramsSerializer:i,timeout:i,timeoutMessage:i,withCredentials:i,withXSRFToken:i,adapter:i,responseType:i,xsrfCookieName:i,xsrfHeaderName:i,onUploadProgress:i,onDownloadProgress:i,decompress:i,maxContentLength:i,maxBodyLength:i,beforeRedirect:i,transport:i,httpAgent:i,httpsAgent:i,cancelToken:i,socketPath:i,responseEncoding:i,validateStatus:l,headers:(I,g)=>n(nt(I),nt(g),!0)};return p.forEach(Object.keys(Object.assign({},A,e)),function(g){let u=c[g]||n,f=u(A[g],e[g],g);p.isUndefined(f)&&u!==l||(t[g]=f)}),t}var yA="1.6.2";var jA={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{jA[A]=function(r){return typeof r===A||"a"+(e<1?"n ":" ")+A}});var ot={};jA.transitional=function(e,t,r){function n(o,i){return"[Axios v"+yA+"] Transitional option '"+o+"'"+i+(r?". "+r:"")}return(o,i,l)=>{if(e===!1)throw new h(n(i," has been removed"+(t?" in "+t:"")),h.ERR_DEPRECATED);return t&&!ot[i]&&(ot[i]=!0,console.warn(n(i," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(o,i,l):!0}};function qr(A,e,t){if(typeof A!="object")throw new h("options must be an object",h.ERR_BAD_OPTION_VALUE);let r=Object.keys(A),n=r.length;for(;n-- >0;){let o=r[n],i=e[o];if(i){let l=A[o],c=l===void 0||i(l,o,A);if(c!==!0)throw new h("option "+o+" must be "+c,h.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new h("Unknown option "+o,h.ERR_BAD_OPTION)}}var wA={assertOptions:qr,validators:jA};var T=wA.validators,z=class{constructor(e){this.defaults=e,this.interceptors={request:new xA,response:new xA}}request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=x(this.defaults,t);let{transitional:r,paramsSerializer:n,headers:o}=t;r!==void 0&&wA.assertOptions(r,{silentJSONParsing:T.transitional(T.boolean),forcedJSONParsing:T.transitional(T.boolean),clarifyTimeoutError:T.transitional(T.boolean)},!1),n!=null&&(p.isFunction(n)?t.paramsSerializer={serialize:n}:wA.assertOptions(n,{encode:T.function,serialize:T.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let i=o&&p.merge(o.common,o[t.method]);o&&p.forEach(["delete","get","head","post","put","patch","common"],s=>{delete o[s]}),t.headers=k.concat(i,o);let l=[],c=!0;this.interceptors.request.forEach(function(C){typeof C.runWhen=="function"&&C.runWhen(t)===!1||(c=c&&C.synchronous,l.unshift(C.fulfilled,C.rejected))});let I=[];this.interceptors.response.forEach(function(C){I.push(C.fulfilled,C.rejected)});let g,u=0,f;if(!c){let s=[hA.bind(this),void 0];for(s.unshift.apply(s,l),s.push.apply(s,I),f=s.length,g=Promise.resolve(t);u<f;)g=g.then(s[u++],s[u++]);return g}f=l.length;let a=t;for(u=0;u<f;){let s=l[u++],C=l[u++];try{a=s(a)}catch(m){C.call(this,m);break}}try{g=hA.call(this,a)}catch(s){return Promise.reject(s)}for(u=0,f=I.length;u<f;)g=g.then(I[u++],I[u++]);return g}getUri(e){e=x(this.defaults,e);let t=IA(e.baseURL,e.url);return nA(t,e.params,e.paramsSerializer)}};p.forEach(["delete","get","head","options"],function(e){z.prototype[e]=function(t,r){return this.request(x(r||{},{method:e,url:t,data:(r||{}).data}))}});p.forEach(["post","put","patch"],function(e){function t(r){return function(o,i,l){return this.request(x(l||{},{method:e,headers:r?{"Content-Type":"multipart/form-data"}:{},url:o,data:i}))}}z.prototype[e]=t(),z.prototype[e+"Form"]=t(!0)});var lA=z;var _A=class A{constructor(e){if(typeof e!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(o){t=o});let r=this;this.promise.then(n=>{if(!r._listeners)return;let o=r._listeners.length;for(;o-- >0;)r._listeners[o](n);r._listeners=null}),this.promise.then=n=>{let o,i=new Promise(l=>{r.subscribe(l),o=l}).then(n);return i.cancel=function(){r.unsubscribe(o)},i},e(function(o,i,l){r.reason||(r.reason=new G(o,i,l),t(r.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(e){if(this.reason){e(this.reason);return}this._listeners?this._listeners.push(e):this._listeners=[e]}unsubscribe(e){if(!this._listeners)return;let t=this._listeners.indexOf(e);t!==-1&&this._listeners.splice(t,1)}static source(){let e;return{token:new A(function(n){e=n}),cancel:e}}},at=_A;function zA(A){return function(t){return A.apply(null,t)}}function VA(A){return p.isObject(A)&&A.isAxiosError===!0}var ZA={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(ZA).forEach(([A,e])=>{ZA[e]=A});var st=ZA;function It(A){let e=new lA(A),t=tA(lA.prototype.request,e);return p.extend(t,lA.prototype,e,{allOwnKeys:!0}),p.extend(t,e,null,{allOwnKeys:!0}),t.create=function(n){return It(x(A,n))},t}var b=It(j);b.Axios=lA;b.CanceledError=G;b.CancelToken=at;b.isCancel=sA;b.VERSION=yA;b.toFormData=W;b.AxiosError=h;b.Cancel=b.CanceledError;b.all=function(e){return Promise.all(e)};b.spread=zA;b.isAxiosError=VA;b.mergeConfig=x;b.AxiosHeaders=k;b.formToJSON=A=>dA(p.isHTMLForm(A)?new FormData(A):A);b.getAdapter=QA.getAdapter;b.HttpStatusCode=st;b.default=b;var H=b;var{Axios:Pa,AxiosError:xa,CanceledError:Wa,isCancel:Ga,CancelToken:Ta,VERSION:La,all:Ja,Cancel:Ha,isAxiosError:Ya,spread:qa,toFormData:Ka,AxiosHeaders:va,HttpStatusCode:ja,formToJSON:_a,getAdapter:za,mergeConfig:Va}=H;var gt=Symbol("Comlink.proxy"),Kr=Symbol("Comlink.endpoint"),Ae=Symbol("Comlink.releaseProxy"),XA=Symbol("Comlink.finalizer"),bA=Symbol("Comlink.thrown"),ut=A=>typeof A=="object"&&A!==null||typeof A=="function",vr={canHandle:A=>ut(A)&&A[gt],serialize(A){let{port1:e,port2:t}=new MessageChannel;return pt(A,e),[t,[t]]},deserialize(A){return A.start(),ee(A)}},jr={canHandle:A=>ut(A)&&bA in A,serialize({value:A}){let e;return A instanceof Error?e={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:e={isError:!1,value:A},[e,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},ft=new Map([["proxy",vr],["throw",jr]]);function _r(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function pt(A,e=globalThis,t=["*"]){e.addEventListener("message",function r(n){if(!n||!n.data)return;if(!_r(t,n.origin)){console.warn(`Invalid origin '${n.origin}' for comlink proxy`);return}let{id:o,type:i,path:l}=Object.assign({path:[]},n.data),c=(n.data.argumentList||[]).map(Y),I;try{let g=l.slice(0,-1).reduce((f,a)=>f[a],A),u=l.reduce((f,a)=>f[a],A);switch(i){case"GET":I=u;break;case"SET":g[l.slice(-1)[0]]=Y(n.data.value),I=!0;break;case"APPLY":I=u.apply(g,c);break;case"CONSTRUCT":{let f=new u(...c);I=$r(f)}break;case"ENDPOINT":{let{port1:f,port2:a}=new MessageChannel;pt(A,a),I=te(f,[f])}break;case"RELEASE":I=void 0;break;default:return}}catch(g){I={value:g,[bA]:0}}Promise.resolve(I).catch(g=>({value:g,[bA]:0})).then(g=>{let[u,f]=SA(g);e.postMessage(Object.assign(Object.assign({},u),{id:o}),f),i==="RELEASE"&&(e.removeEventListener("message",r),ct(e),XA in A&&typeof A[XA]=="function"&&A[XA]())}).catch(g=>{let[u,f]=SA({value:new TypeError("Unserializable return value"),[bA]:0});e.postMessage(Object.assign(Object.assign({},u),{id:o}),f)})}),e.start&&e.start()}function zr(A){return A.constructor.name==="MessagePort"}function ct(A){zr(A)&&A.close()}function ee(A,e){return $A(A,[],e)}function DA(A){if(A)throw new Error("Proxy has been released and is not useable")}function Bt(A){return V(A,{type:"RELEASE"}).then(()=>{ct(A)})}var FA=new WeakMap,RA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(FA.get(A)||0)-1;FA.set(A,e),e===0&&Bt(A)});function Vr(A,e){let t=(FA.get(e)||0)+1;FA.set(e,t),RA&&RA.register(A,e,A)}function Zr(A){RA&&RA.unregister(A)}function $A(A,e=[],t=function(){}){let r=!1,n=new Proxy(t,{get(o,i){if(DA(r),i===Ae)return()=>{Zr(n),Bt(A),r=!0};if(i==="then"){if(e.length===0)return{then:()=>n};let l=V(A,{type:"GET",path:e.map(c=>c.toString())}).then(Y);return l.then.bind(l)}return $A(A,[...e,i])},set(o,i,l){DA(r);let[c,I]=SA(l);return V(A,{type:"SET",path:[...e,i].map(g=>g.toString()),value:c},I).then(Y)},apply(o,i,l){DA(r);let c=e[e.length-1];if(c===Kr)return V(A,{type:"ENDPOINT"}).then(Y);if(c==="bind")return $A(A,e.slice(0,-1));let[I,g]=lt(l);return V(A,{type:"APPLY",path:e.map(u=>u.toString()),argumentList:I},g).then(Y)},construct(o,i){DA(r);let[l,c]=lt(i);return V(A,{type:"CONSTRUCT",path:e.map(I=>I.toString()),argumentList:l},c).then(Y)}});return Vr(n,A),n}function Xr(A){return Array.prototype.concat.apply([],A)}function lt(A){let e=A.map(SA);return[e.map(t=>t[0]),Xr(e.map(t=>t[1]))]}var Ct=new WeakMap;function te(A,e){return Ct.set(A,e),A}function $r(A){return Object.assign(A,{[gt]:!0})}function SA(A){for(let[e,t]of ft)if(t.canHandle(A)){let[r,n]=t.serialize(A);return[{type:"HANDLER",name:e,value:r},n]}return[{type:"RAW",value:A},Ct.get(A)||[]]}function Y(A){switch(A.type){case"HANDLER":return ft.get(A.name).deserialize(A.value);case"RAW":return A.value}}function V(A,e,t){return new Promise(r=>{let n=Ai();A.addEventListener("message",function o(i){!i.data||!i.data.id||i.data.id!==n||(A.removeEventListener("message",o),r(i.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:n},e),t)})}function Ai(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function dt(A){let e=ee(A),t=A;return t.workerProxy=e,t.originalTerminate=t.terminate,t.terminate=()=>{t.workerProxy[Ae](),t.originalTerminate()},{workerProxy:e,worker:t}}async function ei(A,e){let t;if(A!=null){let i=A;return i.workerProxy!==void 0?(t=i.workerProxy,{workerProxy:t,worker:i}):dt(A)}let r=typeof e>"u"?q.pipelineWorkerUrl:e,n=null,o=q.webWorkersUrl;if(typeof o<"u"){console.warn("itkConfig webWorkersUrl is deprecated. Please use pipelineWorkerUrl with the full path to the pipeline worker.");let i="min.",l=o;if(l.startsWith("http")){let c=await H.get(`${l}/bundles/pipeline.${i}worker.js`,{responseType:"blob"}),I=URL.createObjectURL(c.data);n=new Worker(I,{type:"module"})}else n=new Worker(`${l}/bundles/pipeline.${i}worker.js`,{type:"module"})}else if(r===null)n=new Worker(new URL("./web-workers/itk-wasm-pipeline.worker.js",import.meta.url),{type:"module"});else if(r.startsWith("http")){let i=await H.get(r,{responseType:"blob"}),l=URL.createObjectURL(i.data);n=new Worker(l,{type:"module"})}else n=new Worker(r,{type:"module"});return dt(n)}var Et=ei;var ti;function Qt(){return ti}var ri;function ht(){return ri}function ii(A){let e=A.slice((A.lastIndexOf(".")-1>>>0)+2);if(e.toLowerCase()==="gz"){let t=A.slice(0,-3).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="cbor"){let t=A.slice(0,-5).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="zst"){let t=A.slice(0,-10).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="zip"){let t=A.slice(0,-4).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}return e}var gA=ii;function ni(A){return[A.data,A.direction]}var re=ni;function oi(A){return[A.points,A.pointData,A.cells,A.cellData]}var yt=oi;async function ai(A,e){let t="unknown";typeof A!="string"?t=A.href:A.startsWith("http")?t=A:t=`${e}/${A}`,t.endsWith(".js")&&(t=t.substring(0,t.length-3)),t.endsWith(".wasm")&&(t=t.substring(0,t.length-5));let r=`${t}.wasm`,o=(await H.get(r,{responseType:"arraybuffer"})).data;return(await import(`${t}.js`)).default({wasmBinary:o})}var wt=ai;var Dt=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,10,1,8,0,65,0,253,15,253,98,11]));var Rt=typeof globalThis.SharedArrayBuffer=="function",bt=new TextEncoder,Ft=new TextDecoder("utf-8");function L(A,e){let t={flags:"r",encoding:"binary"},r=A.fs_open(e,t.flags),o=A.fs_stat(e).size,i=null;Rt?i=new SharedArrayBuffer(o):i=new ArrayBuffer(o);let l=new Uint8Array(i);return A.fs_read(r,l,0,o,0),A.fs_close(r),l}function St(A,e,t){let r=null;Rt?r=new SharedArrayBuffer(t):r=new ArrayBuffer(t);let n=new Uint8Array(r),o=new Uint8Array(A.HEAPU8.buffer,e,t);return n.set(o),n}function R(A,e,t,r){let n=0;return e!==null&&(n=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,r,e.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(e.buffer),n)),n}function Z(A,e,t){let r=JSON.stringify(e),n=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,r.length]);A.writeAsciiToMemory(r,n,!1)}function N(A,e,t,r){let n=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,e,t]),o=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,e,t]),i=St(A,n,o);return F(r,i.buffer)}function ie(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e]),r=A.AsciiToString(t);return JSON.parse(r)}function si(A,e,t,r){r!=null&&r.length>0&&r.forEach(function(I,g){var u;switch(I.type){case B.TextStream:{let f=bt.encode(I.data.data),a=R(A,f,g,0),s={size:f.buffer.byteLength,data:`data:application/vnd.itk.address,0:${a}`};Z(A,s,g);break}case B.JsonCompatible:{let f=bt.encode(JSON.stringify(I.data)),a=R(A,f,g,0),s={size:f.buffer.byteLength,data:`data:application/vnd.itk.address,0:${a}`};Z(A,s,g);break}case B.BinaryStream:{let f=I.data.data,a=R(A,f,g,0),s={size:f.buffer.byteLength,data:`data:application/vnd.itk.address,0:${a}`};Z(A,s,g);break}case B.TextFile:{A.fs_writeFile(I.data.path,I.data.data);break}case B.BinaryFile:{A.fs_writeFile(I.data.path,I.data.data);break}case B.Image:{let f=I.data,a=R(A,f.data,g,0),s=R(A,f.direction,g,1),C=typeof((u=f.metadata)===null||u===void 0?void 0:u.entries)<"u"?JSON.stringify(Array.from(f.metadata.entries())):"[]",m={imageType:f.imageType,name:f.name,origin:f.origin,spacing:f.spacing,direction:`data:application/vnd.itk.address,0:${s}`,size:f.size,data:`data:application/vnd.itk.address,0:${a}`,metadata:C};Z(A,m,g);break}case B.Mesh:{let f=I.data,a=R(A,f.points,g,0),s=R(A,f.cells,g,1),C=R(A,f.pointData,g,2),m=R(A,f.cellData,g,3),w={meshType:f.meshType,name:f.name,numberOfPoints:f.numberOfPoints,points:`data:application/vnd.itk.address,0:${a}`,numberOfCells:f.numberOfCells,cells:`data:application/vnd.itk.address,0:${s}`,cellBufferSize:f.cellBufferSize,numberOfPointPixels:f.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${C}`,numberOfCellPixels:f.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${m}`};Z(A,w,g);break}case B.PolyData:{let f=I.data,a=R(A,f.points,g,0),s=R(A,f.vertices,g,1),C=R(A,f.lines,g,2),m=R(A,f.polygons,g,3),w=R(A,f.triangleStrips,g,4),y=R(A,f.pointData,g,5),D=R(A,f.pointData,g,6),kA={polyDataType:f.polyDataType,name:f.name,numberOfPoints:f.numberOfPoints,points:`data:application/vnd.itk.address,0:${a}`,verticesBufferSize:f.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${s}`,linesBufferSize:f.linesBufferSize,lines:`data:application/vnd.itk.address,0:${C}`,polygonsBufferSize:f.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${m}`,triangleStripsBufferSize:f.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${w}`,numberOfPointPixels:f.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${y}`,numberOfCellPixels:f.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${D}`};Z(A,kA,g);break}case U.Text:{A.fs_writeFile(I.path,I.data);break}case U.Binary:{A.fs_writeFile(I.path,I.data);break}case U.Image:{let f=I.data,a={imageType:f.imageType,name:f.name,origin:f.origin,spacing:f.spacing,direction:"data:application/vnd.itk.path,data/direction.raw",size:f.size,data:"data:application/vnd.itk.path,data/data.raw"};if(A.fs_mkdirs(`${I.path}/data`),A.fs_writeFile(`${I.path}/index.json`,JSON.stringify(a)),f.data===null)throw Error("image.data is null");A.fs_writeFile(`${I.path}/data/data.raw`,new Uint8Array(f.data.buffer)),A.fs_writeFile(`${I.path}/data/direction.raw`,new Uint8Array(f.direction.buffer));break}case U.Mesh:{let f=I.data,a={meshType:f.meshType,name:f.name,numberOfPoints:f.numberOfPoints,points:"data:application/vnd.itk.path,data/points.raw",numberOfPointPixels:f.numberOfPointPixels,pointData:"data:application/vnd.itk.path,data/pointData.raw",numberOfCells:f.numberOfCells,cells:"data:application/vnd.itk.path,data/cells.raw",numberOfCellPixels:f.numberOfCellPixels,cellData:"data:application/vnd.itk.path,data/cellData.raw",cellBufferSize:f.cellBufferSize};if(A.fs_mkdirs(`${I.path}/data`),A.fs_writeFile(`${I.path}/index.json`,JSON.stringify(a)),a.numberOfPoints>0){if(f.points===null)throw Error("mesh.points is null");A.fs_writeFile(`${I.path}/data/points.raw`,new Uint8Array(f.points.buffer))}if(a.numberOfPointPixels>0){if(f.pointData===null)throw Error("mesh.pointData is null");A.fs_writeFile(`${I.path}/data/pointData.raw`,new Uint8Array(f.pointData.buffer))}if(a.numberOfCells>0){if(f.cells===null)throw Error("mesh.cells is null");A.fs_writeFile(`${I.path}/data/cells.raw`,new Uint8Array(f.cells.buffer))}if(a.numberOfCellPixels>0){if(f.cellData===null)throw Error("mesh.cellData is null");A.fs_writeFile(`${I.path}/data/cellData.raw`,new Uint8Array(f.cellData.buffer))}break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let n=A.stackSave(),o=0;try{o=A.callMain(e.slice())}catch(I){throw typeof I=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(I)):console.error("Build module in Debug mode for exception message information.")),I}finally{A.stackRestore(n)}let i=A.getModuleStdout(),l=A.getModuleStderr(),c=[];return t!=null&&t.length>0&&o===0&&t.forEach(function(I,g){let u=null;switch(I.type){case B.TextStream:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0]),s=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]),C=new Uint8Array(A.HEAPU8.buffer,a,s);u={data:Ft.decode(C)};break}case B.JsonCompatible:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0]),s=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]),C=new Uint8Array(A.HEAPU8.buffer,a,s);u=JSON.parse(Ft.decode(C));break}case B.BinaryStream:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0]),s=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]);u={data:St(A,a,s)};break}case B.TextFile:{u={path:I.data.path,data:A.fs_readFile(I.data.path,{encoding:"utf8"})};break}case B.BinaryFile:{u={path:I.data.path,data:L(A,I.data.path)};break}case B.Image:{let a=ie(A,g);a.data=N(A,g,0,a.imageType.componentType),a.direction=N(A,g,1,J.Float64),a.metadata=new Map(a.metadata),u=a;break}case B.Mesh:{let a=ie(A,g);a.numberOfPoints>0?a.points=N(A,g,0,a.meshType.pointComponentType):a.points=F(a.meshType.pointComponentType,new ArrayBuffer(0)),a.numberOfCells>0?a.cells=N(A,g,1,a.meshType.cellComponentType):a.cells=F(a.meshType.cellComponentType,new ArrayBuffer(0)),a.numberOfPointPixels>0?a.pointData=N(A,g,2,a.meshType.pointPixelComponentType):a.pointData=F(a.meshType.pointPixelComponentType,new ArrayBuffer(0)),a.numberOfCellPixels>0?a.cellData=N(A,g,3,a.meshType.cellPixelComponentType):a.cellData=F(a.meshType.cellPixelComponentType,new ArrayBuffer(0)),u=a;break}case B.PolyData:{let a=ie(A,g);a.numberOfPoints>0?a.points=N(A,g,0,J.Float32):a.points=new Float32Array,a.verticesBufferSize>0?a.vertices=N(A,g,1,O.UInt32):a.vertices=new Uint32Array,a.linesBufferSize>0?a.lines=N(A,g,2,O.UInt32):a.lines=new Uint32Array,a.polygonsBufferSize>0?a.polygons=N(A,g,3,O.UInt32):a.polygons=new Uint32Array,a.triangleStripsBufferSize>0?a.triangleStrips=N(A,g,4,O.UInt32):a.triangleStrips=new Uint32Array,a.numberOfPointPixels>0?a.pointData=N(A,g,5,a.polyDataType.pointPixelComponentType):a.pointData=F(a.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),a.numberOfCellPixels>0?a.cellData=N(A,g,6,a.polyDataType.cellPixelComponentType):a.cellData=F(a.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),u=a;break}case U.Text:{if(typeof I.path>"u")throw new Error("output.path not defined");u=A.fs_readFile(I.path,{encoding:"utf8"});break}case U.Binary:{if(typeof I.path>"u")throw new Error("output.path not defined");u=L(A,I.path);break}case U.Image:{if(typeof I.path>"u")throw new Error("output.path not defined");let a=A.fs_readFile(`${I.path}/index.json`,{encoding:"utf8"}),s=JSON.parse(a),C=L(A,`${I.path}/data/data.raw`);s.data=F(s.imageType.componentType,C.buffer);let m=L(A,`${I.path}/data/direction.raw`);s.direction=F(J.Float64,m.buffer),u=s;break}case U.Mesh:{if(typeof I.path>"u")throw new Error("output.path not defined");let a=A.fs_readFile(`${I.path}/index.json`,{encoding:"utf8"}),s=JSON.parse(a);if(s.numberOfPoints>0){let C=L(A,`${I.path}/data/points.raw`);s.points=F(s.meshType.pointComponentType,C.buffer)}else s.points=F(s.meshType.pointComponentType,new ArrayBuffer(0));if(s.numberOfPointPixels>0){let C=L(A,`${I.path}/data/pointData.raw`);s.pointData=F(s.meshType.pointPixelComponentType,C.buffer)}else s.pointData=F(s.meshType.pointPixelComponentType,new ArrayBuffer(0));if(s.numberOfCells>0){let C=L(A,`${I.path}/data/cells.raw`);s.cells=F(s.meshType.cellComponentType,C.buffer)}else s.cells=F(s.meshType.cellComponentType,new ArrayBuffer(0));if(s.numberOfCellPixels>0){let C=L(A,`${I.path}/data/cellData.raw`);s.cellData=F(s.meshType.cellPixelComponentType,C.buffer)}else s.cellData=F(s.meshType.cellPixelComponentType,new ArrayBuffer(0));u=s;break}default:throw Error("Unsupported output InterfaceType")}let f={type:I.type,data:u};c.push(f)}),{returnValue:o,stdout:i,stderr:l,outputs:c}}var kt=si;var ne=new Map;async function Ii(A){let e=A,t=A;if(typeof A!="string"&&(e=new URL(A.href),t=e.href),ne.has(t))return ne.get(t);{let r=await wt(A,q.pipelinesUrl);return ne.set(t,r),r}}async function li(A,e,t,r,n,o){var i,l;if(!await Dt()){let y="WebAssembly SIMD support is required -- please update your browser.";throw alert(y),new Error(y)}if(A===!1){let y=await Ii(e.toString());return kt(y,t,r,n)}let c=A,I=(i=o?.pipelineWorkerUrl)!==null&&i!==void 0?i:null,g=typeof I!="string"&&typeof I?.href<"u"?I.href:I,{workerProxy:u,worker:f}=await Et(c,g);c=f;let a=[];n!=null&&n.length>0&&n.forEach(function(y){if(y.type===B.BinaryStream){let D=y.data.data;a.push(D)}else if(y.type===B.BinaryFile){let D=y.data.data;a.push(D)}else if(y.type===B.Image){let D=y.data;if(D.data===null)throw Error("image data cannot be null");a.push(...re(D))}else if(y.type===U.Binary)a.push(y.data);else if(y.type===U.Image){let D=y.data;if(D.data===null)throw Error("image data cannot be null");a.push(...re(D))}else if(y.type===U.Mesh){let D=y.data;a.push(...yt(D))}});let s=(l=o?.pipelineBaseUrl)!==null&&l!==void 0?l:"pipelinesUrl",C=typeof s!="string"&&typeof s?.href<"u"?s.href:s,m=n!=null?te(n,Re(a)):null,w=await u.runPipeline(q,e.toString(),C,t,r,m);return{returnValue:w.returnValue,stdout:w.stdout,stderr:w.stderr,outputs:w.outputs,webWorker:c}}var d=li;var Ot={name:"@itk-wasm/mesh-io",version:"0.1.0",description:"Input and output for scientific and medical image file formats.",type:"module",module:"./dist/index.js",types:"./dist/index.d.ts",exports:{".":{types:"./dist/index.d.ts",browser:"./dist/index.js",node:"./dist/index-node.js",default:"./dist/index.js"}},scripts:{start:"npm run copyShoelaceAssets && vite",test:"npm run test:node && npm run test:browser","test:node":"ava","test:browser":"npm run test:browser:chrome && npm run test:browser:firefox","test:browser:firefox":"start-server-and-test start http-get://localhost:5173 cypress:runFirefox","test:browser:chrome":"start-server-and-test start http-get://localhost:5173 cypress:runChrome","test:browser:debug":"start-server-and-test start http-get://localhost:5173 cypress:open","cypress:open":"npx cypress open","cypress:runChrome":"npx cypress run --browser chrome","cypress:runFirefox":"npx cypress run --browser firefox",build:"npm run build:tsc && npm run build:browser:workerEmbedded && npm run build:browser:workerEmbeddedMin && npm run build:demo","build:browser:workerEmbedded":"esbuild --loader:.worker.js=dataurl --bundle --format=esm --outfile=./dist/bundle/index-worker-embedded.js ./src/index-worker-embedded.ts","build:browser:workerEmbeddedMin":"esbuild --minify --loader:.worker.js=dataurl --bundle --format=esm --outfile=./dist/bundle/index-worker-embedded.min.js ./src/index-worker-embedded.min.ts","build:tsc":"tsc --pretty",copyShoelaceAssets:"shx mkdir -p test/browser/demo-app/public && shx cp -r node_modules/@shoelace-style/shoelace/dist/assets test/browser/demo-app/public/","build:demo":"npm run copyShoelaceAssets && vite build"},keywords:["itk","wasm","webassembly","wasi"],author:"",license:"Apache-2.0",dependencies:{"itk-wasm":"^1.0.0-b.154"},devDependencies:{"@itk-wasm/image-io":"^0.2.0","@shoelace-style/shoelace":"^2.5.2","@types/mime-types":"^2.1.4","@types/node":"^20.2.5",ava:"^5.3.1",cypress:"^13.6.0",esbuild:"^0.19.5",shx:"^0.3.4","start-server-and-test":"^2.0.3",typescript:"^5.0.4",vite:"^4.5.0","vite-plugin-static-copy":"^0.17.0"},repository:{type:"git",url:"https://github.com/InsightSoftwareConsortium/itk-wasm"},ava:{files:["test/node/**/*","!test/node/common.js"]}};var oe,ui=`https://cdn.jsdelivr.net/npm/@itk-wasm/mesh-io@${Ot.version}/dist/pipelines`;function Ps(A){oe=A}function E(){if(typeof oe<"u")return oe;let A=ht();return typeof A<"u"?A:ui}var ae,fi=null;function Ut(A){ae=A}function Q(){if(typeof ae<"u")return ae;let A=Qt();return typeof A<"u"?A:fi}var pi=new Map([]),X=pi;var ci=new Map([["vtk","vtk"],["byu","byu"],["fsa","free-surfer-ascii"],["fsb","free-surfer-binary"],["obj","obj"],["off","off"],["stl","stl"],["swc","swc"],["iwm","wasm"],["iwm.cbor","wasm"],["iwm.cbor.zst","wasm-zstd"]]),$=ci;async function Bi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="vtk-poly-data-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var se=Bi;async function Ci(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="vtk-poly-data-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var Ie=Ci;async function mi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="obj-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var le=mi;async function di(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="obj-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var ge=di;async function Ei(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="stl-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var ue=Ei;async function Qi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="stl-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var fe=Qi;async function hi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="off-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var pe=hi;async function yi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="off-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var ce=yi;async function wi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="wasm-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var Be=wi;async function Di(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="wasm-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var Ce=Di;async function bi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="wasm-zstd-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var me=bi;async function Fi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="wasm-zstd-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var de=Fi;async function Ri(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="swc-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var Ee=Ri;async function Si(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="swc-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var Qe=Si;async function ki(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="byu-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var he=ki;async function Oi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="byu-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var ye=Oi;async function Ui(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="free-surfer-ascii-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var we=Ui;async function Ni(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="free-surfer-ascii-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var De=Ni;async function Mi(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="free-surfer-binary-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var be=Mi;async function Pi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="free-surfer-binary-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var Fe=Pi;var xi=new Map([["vtk",[se,Ie]],["obj",[le,ge]],["stl",[ue,fe]],["off",[pe,ce]],["wasm",[Be,Ce]],["wasm-zst",[me,de]],["swc",[Ee,Qe]],["byu",[he,ye]],["free-surfer-ascii",[we,De]],["free-surfer-binary",[be,Fe]]]),AA=xi;async function Wi(A,e,t={}){let r=e.type??"",n=e.name??e.path??"fileName",o=gA(n).toLowerCase(),i=A,l=e;if(e instanceof Blob){let s=await e.arrayBuffer();l={path:e.name,data:new Uint8Array(s)}}let c=null;if(r&&X.has(r))c=X.get(r);else if($.has(o))c=$.get(o);else for(let s of AA.values())if(s[0]!==null){let{webWorker:C,couldRead:m,mesh:w}=await s[0](i,{path:l.path,data:l.data.slice()},{informationOnly:t.informationOnly});if(i=C,m)return{webWorker:i,mesh:w}}if(!c)throw Error("Could not find IO for: "+n);let g=AA.get(c)[0],{webWorker:u,couldRead:f,mesh:a}=await g(i,l,{informationOnly:t.informationOnly});if(i=u,!f)throw Error("Could not read: "+n);return{webWorker:i,mesh:a}}var Gi=Wi;async function Ti(A,e,t,r={}){let n=e,o=r.mimeType,i=gA(t).toLowerCase(),l=A,c=null;if(typeof o<"u"&&X.has(o))c=X.get(o);else if($.has(i))c=$.get(i);else for(let C of AA.values())if(C[1]!==null){let{webWorker:m,couldWrite:w,serializedMesh:y}=await C[1](l,n,t,r);if(l=m,w)return{webWorker:l,serializedMesh:y}}if(!c)throw Error("Could not find IO for: "+t);let g=AA.get(c)[1],{webWorker:u,couldWrite:f,serializedMesh:a}=await g(l,n,t,r);if(l=u,!f)throw Error("Could not write: "+t);return{webWorker:l,serializedMesh:a}}var Li=Ti;async function Ji(A,e,t={}){let r=[{type:B.JsonCompatible},{type:B.Mesh}],n=e;if(e instanceof File){let m=await e.arrayBuffer();n={path:e.name,data:new Uint8Array(m)}}let o=[{type:B.BinaryFile,data:n}],i=[],l=n.path;i.push(l);let c="0";i.push(c);let I="1";i.push(I),i.push("--memory-io"),typeof t.informationOnly<"u"&&t.informationOnly&&i.push("--information-only");let g="wasm-ztd-read-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,r,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldRead:s[0]?.data,mesh:s[1]?.data}}var Hi=Ji;async function Yi(A,e,t,r={}){let n=[{type:B.JsonCompatible},{type:B.BinaryFile,data:{path:t,data:new Uint8Array}}],o=[{type:B.Mesh,data:e}],i=[],l="0";i.push(l);let c="0";i.push(c);let I=t;i.push(I),i.push("--memory-io"),typeof r.informationOnly<"u"&&r.informationOnly&&i.push("--information-only"),typeof r.useCompression<"u"&&r.useCompression&&i.push("--use-compression"),typeof r.binaryFileType<"u"&&r.binaryFileType&&i.push("--binary-file-type");let g="wasm-ztd-write-mesh",{webWorker:u,returnValue:f,stderr:a,outputs:s}=await d(A,g,i,n,o,{pipelineBaseUrl:E(),pipelineWorkerUrl:Q()});if(f!==0&&a!=="")throw new Error(a);return{webWorker:u,couldWrite:s[0]?.data,serializedMesh:s[1]?.data}}var qi=Yi;var Nt='data:text/javascript;charset=utf-8,var fe=Symbol("Comlink.proxy"),Bt=Symbol("Comlink.endpoint"),Qt=Symbol("Comlink.releaseProxy"),JA=Symbol("Comlink.finalizer"),sA=Symbol("Comlink.thrown"),le=A=>typeof A=="object"&&A!==null||typeof A=="function",Et={canHandle:A=>le(A)&&A[fe],serialize(A){let{port1:e,port2:t}=new MessageChannel;return EA(A,e),[t,[t]]},deserialize(A){return A.start(),ut(A)}},ct={canHandle:A=>le(A)&&sA in A,serialize({value:A}){let e;return A instanceof Error?e={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:e={isError:!1,value:A},[e,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},ue=new Map([["proxy",Et],["throw",ct]]);function ft(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function EA(A,e=globalThis,t=["*"]){e.addEventListener("message",function I(r){if(!r||!r.data)return;if(!ft(t,r.origin)){console.warn(`Invalid origin \'${r.origin}\' for comlink proxy`);return}let{id:i,type:g,path:n}=Object.assign({path:[]},r.data),E=(r.data.argumentList||[]).map(q),C;try{let o=n.slice(0,-1).reduce((a,B)=>a[B],A),c=n.reduce((a,B)=>a[B],A);switch(g){case"GET":C=c;break;case"SET":o[n.slice(-1)[0]]=q(r.data.value),C=!0;break;case"APPLY":C=c.apply(o,E);break;case"CONSTRUCT":{let a=new c(...E);C=Dt(a)}break;case"ENDPOINT":{let{port1:a,port2:B}=new MessageChannel;EA(A,B),C=bA(a,[a])}break;case"RELEASE":C=void 0;break;default:return}}catch(o){C={value:o,[sA]:0}}Promise.resolve(C).catch(o=>({value:o,[sA]:0})).then(o=>{let[c,a]=QA(o);e.postMessage(Object.assign(Object.assign({},c),{id:i}),a),g==="RELEASE"&&(e.removeEventListener("message",I),de(e),JA in A&&typeof A[JA]=="function"&&A[JA]())}).catch(o=>{let[c,a]=QA({value:new TypeError("Unserializable return value"),[sA]:0});e.postMessage(Object.assign(Object.assign({},c),{id:i}),a)})}),e.start&&e.start()}function lt(A){return A.constructor.name==="MessagePort"}function de(A){lt(A)&&A.close()}function ut(A,e){return MA(A,[],e)}function aA(A){if(A)throw new Error("Proxy has been released and is not useable")}function he(A){return x(A,{type:"RELEASE"}).then(()=>{de(A)})}var CA=new WeakMap,BA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(CA.get(A)||0)-1;CA.set(A,e),e===0&&he(A)});function dt(A,e){let t=(CA.get(e)||0)+1;CA.set(e,t),BA&&BA.register(A,e,A)}function ht(A){BA&&BA.unregister(A)}function MA(A,e=[],t=function(){}){let I=!1,r=new Proxy(t,{get(i,g){if(aA(I),g===Qt)return()=>{ht(r),he(A),I=!0};if(g==="then"){if(e.length===0)return{then:()=>r};let n=x(A,{type:"GET",path:e.map(E=>E.toString())}).then(q);return n.then.bind(n)}return MA(A,[...e,g])},set(i,g,n){aA(I);let[E,C]=QA(n);return x(A,{type:"SET",path:[...e,g].map(o=>o.toString()),value:E},C).then(q)},apply(i,g,n){aA(I);let E=e[e.length-1];if(E===Bt)return x(A,{type:"ENDPOINT"}).then(q);if(E==="bind")return MA(A,e.slice(0,-1));let[C,o]=ce(n);return x(A,{type:"APPLY",path:e.map(c=>c.toString()),argumentList:C},o).then(q)},construct(i,g){aA(I);let[n,E]=ce(g);return x(A,{type:"CONSTRUCT",path:e.map(C=>C.toString()),argumentList:n},E).then(q)}});return dt(r,A),r}function mt(A){return Array.prototype.concat.apply([],A)}function ce(A){let e=A.map(QA);return[e.map(t=>t[0]),mt(e.map(t=>t[1]))]}var me=new WeakMap;function bA(A,e){return me.set(A,e),A}function Dt(A){return Object.assign(A,{[fe]:!0})}function QA(A){for(let[e,t]of ue)if(t.canHandle(A)){let[I,r]=t.serialize(A);return[{type:"HANDLER",name:e,value:I},r]}return[{type:"RAW",value:A},me.get(A)||[]]}function q(A){switch(A.type){case"HANDLER":return ue.get(A.name).deserialize(A.value);case"RAW":return A.value}}function x(A,e,t){return new Promise(I=>{let r=yt();A.addEventListener("message",function i(g){!g.data||!g.data.id||g.data.id!==r||(A.removeEventListener("message",i),I(g.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:r},e),t)})}function yt(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function X(A,e){return function(){return A.apply(e,arguments)}}var{toString:wt}=Object.prototype,{getPrototypeOf:qA}=Object,fA=(A=>e=>{let t=wt.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),k=A=>(A=A.toLowerCase(),e=>fA(e)===A),lA=A=>e=>typeof e===A,{isArray:P}=Array,v=lA("undefined");function pt(A){return A!==null&&!v(A)&&A.constructor!==null&&!v(A.constructor)&&G(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var pe=k("ArrayBuffer");function Ft(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&pe(A.buffer),e}var St=lA("string"),G=lA("function"),Fe=lA("number"),uA=A=>A!==null&&typeof A=="object",Nt=A=>A===!0||A===!1,cA=A=>{if(fA(A)!=="object")return!1;let e=qA(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},Rt=k("Date"),Gt=k("File"),Ut=k("Blob"),kt=k("FileList"),Lt=A=>uA(A)&&G(A.pipe),Ot=A=>{let e;return A&&(typeof FormData=="function"&&A instanceof FormData||G(A.append)&&((e=fA(A))==="formdata"||e==="object"&&G(A.toString)&&A.toString()==="[object FormData]"))},Jt=k("URLSearchParams"),Mt=A=>A.trim?A.trim():A.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,"");function $(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let I,r;if(typeof A!="object"&&(A=[A]),P(A))for(I=0,r=A.length;I<r;I++)e.call(null,A[I],I,A);else{let i=t?Object.getOwnPropertyNames(A):Object.keys(A),g=i.length,n;for(I=0;I<g;I++)n=i[I],e.call(null,A[n],n,A)}}function Se(A,e){e=e.toLowerCase();let t=Object.keys(A),I=t.length,r;for(;I-- >0;)if(r=t[I],e===r.toLowerCase())return r;return null}var Ne=(()=>typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global)(),Re=A=>!v(A)&&A!==Ne;function YA(){let{caseless:A}=Re(this)&&this||{},e={},t=(I,r)=>{let i=A&&Se(e,r)||r;cA(e[i])&&cA(I)?e[i]=YA(e[i],I):cA(I)?e[i]=YA({},I):P(I)?e[i]=I.slice():e[i]=I};for(let I=0,r=arguments.length;I<r;I++)arguments[I]&&$(arguments[I],t);return e}var bt=(A,e,t,{allOwnKeys:I}={})=>($(e,(r,i)=>{t&&G(r)?A[i]=X(r,t):A[i]=r},{allOwnKeys:I}),A),Ht=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),Yt=(A,e,t,I)=>{A.prototype=Object.create(e.prototype,I),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},qt=(A,e,t,I)=>{let r,i,g,n={};if(e=e||{},A==null)return e;do{for(r=Object.getOwnPropertyNames(A),i=r.length;i-- >0;)g=r[i],(!I||I(g,A,e))&&!n[g]&&(e[g]=A[g],n[g]=!0);A=t!==!1&&qA(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},Tt=(A,e,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=e.length;let I=A.indexOf(e,t);return I!==-1&&I===t},Kt=A=>{if(!A)return null;if(P(A))return A;let e=A.length;if(!Fe(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},xt=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&qA(Uint8Array)),Pt=(A,e)=>{let I=(A&&A[Symbol.iterator]).call(A),r;for(;(r=I.next())&&!r.done;){let i=r.value;e.call(A,i[0],i[1])}},Wt=(A,e)=>{let t,I=[];for(;(t=A.exec(e))!==null;)I.push(t);return I},jt=k("HTMLFormElement"),Zt=A=>A.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,function(t,I,r){return I.toUpperCase()+r}),ye=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),_t=k("RegExp"),Ge=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),I={};$(t,(r,i)=>{let g;(g=e(r,i,A))!==!1&&(I[i]=g||r)}),Object.defineProperties(A,I)},Vt=A=>{Ge(A,(e,t)=>{if(G(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let I=A[t];if(G(I)){if(e.enumerable=!1,"writable"in e){e.writable=!1;return}e.set||(e.set=()=>{throw Error("Can not rewrite read-only method \'"+t+"\'")})}})},zt=(A,e)=>{let t={},I=r=>{r.forEach(i=>{t[i]=!0})};return P(A)?I(A):I(String(A).split(e)),t},Xt=()=>{},vt=(A,e)=>(A=+A,Number.isFinite(A)?A:e),HA="abcdefghijklmnopqrstuvwxyz",we="0123456789",Ue={DIGIT:we,ALPHA:HA,ALPHA_DIGIT:HA+HA.toUpperCase()+we},$t=(A=16,e=Ue.ALPHA_DIGIT)=>{let t="",{length:I}=e;for(;A--;)t+=e[Math.random()*I|0];return t};function AI(A){return!!(A&&G(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var eI=A=>{let e=new Array(10),t=(I,r)=>{if(uA(I)){if(e.indexOf(I)>=0)return;if(!("toJSON"in I)){e[r]=I;let i=P(I)?[]:{};return $(I,(g,n)=>{let E=t(g,r+1);!v(E)&&(i[n]=E)}),e[r]=void 0,i}}return I};return t(A,0)},tI=k("AsyncFunction"),II=A=>A&&(uA(A)||G(A))&&G(A.then)&&G(A.catch),s={isArray:P,isArrayBuffer:pe,isBuffer:pt,isFormData:Ot,isArrayBufferView:Ft,isString:St,isNumber:Fe,isBoolean:Nt,isObject:uA,isPlainObject:cA,isUndefined:v,isDate:Rt,isFile:Gt,isBlob:Ut,isRegExp:_t,isFunction:G,isStream:Lt,isURLSearchParams:Jt,isTypedArray:xt,isFileList:kt,forEach:$,merge:YA,extend:bt,trim:Mt,stripBOM:Ht,inherits:Yt,toFlatObject:qt,kindOf:fA,kindOfTest:k,endsWith:Tt,toArray:Kt,forEachEntry:Pt,matchAll:Wt,isHTMLForm:jt,hasOwnProperty:ye,hasOwnProp:ye,reduceDescriptors:Ge,freezeMethods:Vt,toObjectSet:zt,toCamelCase:Zt,noop:Xt,toFiniteNumber:vt,findKey:Se,global:Ne,isContextDefined:Re,ALPHABET:Ue,generateString:$t,isSpecCompliantForm:AI,toJSONObject:eI,isAsyncFn:tI,isThenable:II};function W(A,e,t,I,r){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",e&&(this.code=e),t&&(this.config=t),I&&(this.request=I),r&&(this.response=r)}s.inherits(W,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:s.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var ke=W.prototype,Le={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{Le[A]={value:A}});Object.defineProperties(W,Le);Object.defineProperty(ke,"isAxiosError",{value:!0});W.from=(A,e,t,I,r,i)=>{let g=Object.create(ke);return s.toFlatObject(A,g,function(E){return E!==Error.prototype},n=>n!=="isAxiosError"),W.call(g,A.message,e,t,I,r),g.cause=A,g.name=A.name,i&&Object.assign(g,i),g};var l=W;var dA=null;function TA(A){return s.isPlainObject(A)||s.isArray(A)}function Je(A){return s.endsWith(A,"[]")?A.slice(0,-2):A}function Oe(A,e,t){return A?A.concat(e).map(function(r,i){return r=Je(r),!t&&i?"["+r+"]":r}).join(t?".":""):e}function rI(A){return s.isArray(A)&&!A.some(TA)}var iI=s.toFlatObject(s,{},null,function(e){return/^is[A-Z]/.test(e)});function gI(A,e,t){if(!s.isObject(A))throw new TypeError("target must be an object");e=e||new(dA||FormData),t=s.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(f,d){return!s.isUndefined(d[f])});let I=t.metaTokens,r=t.visitor||o,i=t.dots,g=t.indexes,E=(t.Blob||typeof Blob<"u"&&Blob)&&s.isSpecCompliantForm(e);if(!s.isFunction(r))throw new TypeError("visitor must be a function");function C(Q){if(Q===null)return"";if(s.isDate(Q))return Q.toISOString();if(!E&&s.isBlob(Q))throw new l("Blob is not supported. Use a Buffer instead.");return s.isArrayBuffer(Q)||s.isTypedArray(Q)?E&&typeof Blob=="function"?new Blob([Q]):Buffer.from(Q):Q}function o(Q,f,d){let F=Q;if(Q&&!d&&typeof Q=="object"){if(s.endsWith(f,"{}"))f=I?f:f.slice(0,-2),Q=JSON.stringify(Q);else if(s.isArray(Q)&&rI(Q)||(s.isFileList(Q)||s.endsWith(f,"[]"))&&(F=s.toArray(Q)))return f=Je(f),F.forEach(function(K,OA){!(s.isUndefined(K)||K===null)&&e.append(g===!0?Oe([f],OA,i):g===null?f:f+"[]",C(K))}),!1}return TA(Q)?!0:(e.append(Oe(d,f,i),C(Q)),!1)}let c=[],a=Object.assign(iI,{defaultVisitor:o,convertValue:C,isVisitable:TA});function B(Q,f){if(!s.isUndefined(Q)){if(c.indexOf(Q)!==-1)throw Error("Circular reference detected in "+f.join("."));c.push(Q),s.forEach(Q,function(F,R){(!(s.isUndefined(F)||F===null)&&r.call(e,F,s.isString(R)?R.trim():R,f,a))===!0&&B(F,f?f.concat(R):[R])}),c.pop()}}if(!s.isObject(A))throw new TypeError("data must be an object");return B(A),e}var J=gI;function Me(A){let e={"!":"%2521","\'":"%2527","(":"%2528",")":"%2529","~":"%257E","%2520":"+","%2500":"\\0"};return encodeURIComponent(A).replace(/[!\'()~]|%2520|%2500/g,function(I){return e[I]})}function be(A,e){this._pairs=[],A&&J(A,this,e)}var He=be.prototype;He.append=function(e,t){this._pairs.push([e,t])};He.toString=function(e){let t=e?function(I){return e.call(this,I,Me)}:Me;return this._pairs.map(function(r){return t(r[0])+"="+t(r[1])},"").join("&")};var hA=be;function oI(A){return encodeURIComponent(A).replace(/%253A/gi,":").replace(/%2524/g,"$").replace(/%252C/gi,",").replace(/%2520/g,"+").replace(/%255B/gi,"[").replace(/%255D/gi,"]")}function AA(A,e,t){if(!e)return A;let I=t&&t.encode||oI,r=t&&t.serialize,i;if(r?i=r(e,t):i=s.isURLSearchParams(e)?e.toString():new hA(e,t).toString(I),i){let g=A.indexOf("%23");g!==-1&&(A=A.slice(0,g)),A+=(A.indexOf("?")===-1?"?":"&")+i}return A}var KA=class{constructor(){this.handlers=[]}use(e,t,I){return this.handlers.push({fulfilled:e,rejected:t,synchronous:I?I.synchronous:!1,runWhen:I?I.runWhen:null}),this.handlers.length-1}eject(e){this.handlers[e]&&(this.handlers[e]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(e){s.forEach(this.handlers,function(I){I!==null&&e(I)})}},xA=KA;var mA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var Ye=typeof URLSearchParams<"u"?URLSearchParams:hA;var qe=typeof FormData<"u"?FormData:null;var Te=typeof Blob<"u"?Blob:null;var nI=(()=>{let A;return typeof navigator<"u"&&((A=navigator.product)==="ReactNative"||A==="NativeScript"||A==="NS")?!1:typeof window<"u"&&typeof document<"u"})(),aI=(()=>typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function")(),D={isBrowser:!0,classes:{URLSearchParams:Ye,FormData:qe,Blob:Te},isStandardBrowserEnv:nI,isStandardBrowserWebWorkerEnv:aI,protocols:["http","https","file","blob","url","data"]};function PA(A,e){return J(A,new D.classes.URLSearchParams,Object.assign({visitor:function(t,I,r,i){return D.isNode&&s.isBuffer(t)?(this.append(I,t.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)}},e))}function sI(A){return s.matchAll(/\\w+|\\[(\\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function CI(A){let e={},t=Object.keys(A),I,r=t.length,i;for(I=0;I<r;I++)i=t[I],e[i]=A[i];return e}function BI(A){function e(t,I,r,i){let g=t[i++],n=Number.isFinite(+g),E=i>=t.length;return g=!g&&s.isArray(r)?r.length:g,E?(s.hasOwnProp(r,g)?r[g]=[r[g],I]:r[g]=I,!n):((!r[g]||!s.isObject(r[g]))&&(r[g]=[]),e(t,I,r[g],i)&&s.isArray(r[g])&&(r[g]=CI(r[g])),!n)}if(s.isFormData(A)&&s.isFunction(A.entries)){let t={};return s.forEachEntry(A,(I,r)=>{e(sI(I),r,t,0)}),t}return null}var DA=BI;function QI(A,e,t){if(s.isString(A))try{return(e||JSON.parse)(A),s.trim(A)}catch(I){if(I.name!=="SyntaxError")throw I}return(t||JSON.stringify)(A)}var WA={transitional:mA,adapter:["xhr","http"],transformRequest:[function(e,t){let I=t.getContentType()||"",r=I.indexOf("application/json")>-1,i=s.isObject(e);if(i&&s.isHTMLForm(e)&&(e=new FormData(e)),s.isFormData(e))return r&&r?JSON.stringify(DA(e)):e;if(s.isArrayBuffer(e)||s.isBuffer(e)||s.isStream(e)||s.isFile(e)||s.isBlob(e))return e;if(s.isArrayBufferView(e))return e.buffer;if(s.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let n;if(i){if(I.indexOf("application/x-www-form-urlencoded")>-1)return PA(e,this.formSerializer).toString();if((n=s.isFileList(e))||I.indexOf("multipart/form-data")>-1){let E=this.env&&this.env.FormData;return J(n?{"files[]":e}:e,E&&new E,this.formSerializer)}}return i||r?(t.setContentType("application/json",!1),QI(e)):e}],transformResponse:[function(e){let t=this.transitional||WA.transitional,I=t&&t.forcedJSONParsing,r=this.responseType==="json";if(e&&s.isString(e)&&(I&&!this.responseType||r)){let g=!(t&&t.silentJSONParsing)&&r;try{return JSON.parse(e)}catch(n){if(g)throw n.name==="SyntaxError"?l.from(n,l.ERR_BAD_RESPONSE,this,null,this.response):n}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:D.classes.FormData,Blob:D.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};s.forEach(["delete","get","head","post","put","patch"],A=>{WA.headers[A]={}});var j=WA;var EI=s.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),Ke=A=>{let e={},t,I,r;return A&&A.split(`%0A`).forEach(function(g){r=g.indexOf(":"),t=g.substring(0,r).trim().toLowerCase(),I=g.substring(r+1).trim(),!(!t||e[t]&&EI[t])&&(t==="set-cookie"?e[t]?e[t].push(I):e[t]=[I]:e[t]=e[t]?e[t]+", "+I:I)}),e};var xe=Symbol("internals");function eA(A){return A&&String(A).trim().toLowerCase()}function yA(A){return A===!1||A==null?A:s.isArray(A)?A.map(yA):String(A)}function cI(A){let e=Object.create(null),t=/([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g,I;for(;I=t.exec(A);)e[I[1]]=I[2];return e}var fI=A=>/^[-_a-zA-Z0-9^`|~,!%23$%&\'*+.]+$/.test(A.trim());function jA(A,e,t,I,r){if(s.isFunction(I))return I.call(this,e,t);if(r&&(e=t),!!s.isString(e)){if(s.isString(I))return e.indexOf(I)!==-1;if(s.isRegExp(I))return I.test(e)}}function lI(A){return A.trim().toLowerCase().replace(/([a-z\\d])(\\w*)/g,(e,t,I)=>t.toUpperCase()+I)}function uI(A,e){let t=s.toCamelCase(" "+e);["get","set","has"].forEach(I=>{Object.defineProperty(A,I+t,{value:function(r,i,g){return this[I].call(this,e,r,i,g)},configurable:!0})})}var Z=class{constructor(e){e&&this.set(e)}set(e,t,I){let r=this;function i(n,E,C){let o=eA(E);if(!o)throw new Error("header name must be a non-empty string");let c=s.findKey(r,o);(!c||r[c]===void 0||C===!0||C===void 0&&r[c]!==!1)&&(r[c||E]=yA(n))}let g=(n,E)=>s.forEach(n,(C,o)=>i(C,o,E));return s.isPlainObject(e)||e instanceof this.constructor?g(e,t):s.isString(e)&&(e=e.trim())&&!fI(e)?g(Ke(e),t):e!=null&&i(t,e,I),this}get(e,t){if(e=eA(e),e){let I=s.findKey(this,e);if(I){let r=this[I];if(!t)return r;if(t===!0)return cI(r);if(s.isFunction(t))return t.call(this,r,I);if(s.isRegExp(t))return t.exec(r);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=eA(e),e){let I=s.findKey(this,e);return!!(I&&this[I]!==void 0&&(!t||jA(this,this[I],I,t)))}return!1}delete(e,t){let I=this,r=!1;function i(g){if(g=eA(g),g){let n=s.findKey(I,g);n&&(!t||jA(I,I[n],n,t))&&(delete I[n],r=!0)}}return s.isArray(e)?e.forEach(i):i(e),r}clear(e){let t=Object.keys(this),I=t.length,r=!1;for(;I--;){let i=t[I];(!e||jA(this,this[i],i,e,!0))&&(delete this[i],r=!0)}return r}normalize(e){let t=this,I={};return s.forEach(this,(r,i)=>{let g=s.findKey(I,i);if(g){t[g]=yA(r),delete t[i];return}let n=e?lI(i):String(i).trim();n!==i&&delete t[i],t[n]=yA(r),I[n]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return s.forEach(this,(I,r)=>{I!=null&&I!==!1&&(t[r]=e&&s.isArray(I)?I.join(", "):I)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([e,t])=>e+": "+t).join(`%0A`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(e){return e instanceof this?e:new this(e)}static concat(e,...t){let I=new this(e);return t.forEach(r=>I.set(r)),I}static accessor(e){let I=(this[xe]=this[xe]={accessors:{}}).accessors,r=this.prototype;function i(g){let n=eA(g);I[n]||(uI(r,g),I[n]=!0)}return s.isArray(e)?e.forEach(i):i(e),this}};Z.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);s.reduceDescriptors(Z.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(I){this[t]=I}}});s.freezeMethods(Z);var w=Z;function tA(A,e){let t=this||j,I=e||t,r=w.from(I.headers),i=I.data;return s.forEach(A,function(n){i=n.call(t,i,r.normalize(),e?e.status:void 0)}),r.normalize(),i}function IA(A){return!!(A&&A.__CANCEL__)}function Pe(A,e,t){l.call(this,A??"canceled",l.ERR_CANCELED,e,t),this.name="CanceledError"}s.inherits(Pe,l,{__CANCEL__:!0});var M=Pe;function ZA(A,e,t){let I=t.config.validateStatus;!t.status||!I||I(t.status)?A(t):e(new l("Request failed with status code "+t.status,[l.ERR_BAD_REQUEST,l.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var We=D.isStandardBrowserEnv?function(){return{write:function(t,I,r,i,g,n){let E=[];E.push(t+"="+encodeURIComponent(I)),s.isNumber(r)&&E.push("expires="+new Date(r).toGMTString()),s.isString(i)&&E.push("path="+i),s.isString(g)&&E.push("domain="+g),n===!0&&E.push("secure"),document.cookie=E.join("; ")},read:function(t){let I=document.cookie.match(new RegExp("(^|;\\\\s*)("+t+")=([^;]*)"));return I?decodeURIComponent(I[3]):null},remove:function(t){this.write(t,"",Date.now()-864e5)}}}():function(){return{write:function(){},read:function(){return null},remove:function(){}}}();function _A(A){return/^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(A)}function VA(A,e){return e?A.replace(/\\/+$/,"")+"/"+e.replace(/^\\/+/,""):A}function rA(A,e){return A&&!_A(e)?VA(A,e):e}var je=D.isStandardBrowserEnv?function(){let e=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),I;function r(i){let g=i;return e&&(t.setAttribute("href",g),g=t.href),t.setAttribute("href",g),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\\?/,""):"",hash:t.hash?t.hash.replace(/^%23/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return I=r(window.location.href),function(g){let n=s.isString(g)?r(g):g;return n.protocol===I.protocol&&n.host===I.host}}():function(){return function(){return!0}}();function zA(A){let e=/^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(A);return e&&e[1]||""}function dI(A,e){A=A||10;let t=new Array(A),I=new Array(A),r=0,i=0,g;return e=e!==void 0?e:1e3,function(E){let C=Date.now(),o=I[i];g||(g=C),t[r]=E,I[r]=C;let c=i,a=0;for(;c!==r;)a+=t[c++],c=c%A;if(r=(r+1)%A,r===i&&(i=(i+1)%A),C-g<e)return;let B=o&&C-o;return B?Math.round(a*1e3/B):void 0}}var Ze=dI;function _e(A,e){let t=0,I=Ze(50,250);return r=>{let i=r.loaded,g=r.lengthComputable?r.total:void 0,n=i-t,E=I(n),C=i<=g;t=i;let o={loaded:i,total:g,progress:g?i/g:void 0,bytes:n,rate:E||void 0,estimated:E&&g&&C?(g-i)/E:void 0,event:r};o[e?"download":"upload"]=!0,A(o)}}var hI=typeof XMLHttpRequest<"u",Ve=hI&&function(A){return new Promise(function(t,I){let r=A.data,i=w.from(A.headers).normalize(),g=A.responseType,n;function E(){A.cancelToken&&A.cancelToken.unsubscribe(n),A.signal&&A.signal.removeEventListener("abort",n)}let C;s.isFormData(r)&&(D.isStandardBrowserEnv||D.isStandardBrowserWebWorkerEnv?i.setContentType(!1):i.getContentType(/^\\s*multipart\\/form-data/)?s.isString(C=i.getContentType())&&i.setContentType(C.replace(/^\\s*(multipart\\/form-data);+/,"$1")):i.setContentType("multipart/form-data"));let o=new XMLHttpRequest;if(A.auth){let Q=A.auth.username||"",f=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";i.set("Authorization","Basic "+btoa(Q+":"+f))}let c=rA(A.baseURL,A.url);o.open(A.method.toUpperCase(),AA(c,A.params,A.paramsSerializer),!0),o.timeout=A.timeout;function a(){if(!o)return;let Q=w.from("getAllResponseHeaders"in o&&o.getAllResponseHeaders()),d={data:!g||g==="text"||g==="json"?o.responseText:o.response,status:o.status,statusText:o.statusText,headers:Q,config:A,request:o};ZA(function(R){t(R),E()},function(R){I(R),E()},d),o=null}if("onloadend"in o?o.onloadend=a:o.onreadystatechange=function(){!o||o.readyState!==4||o.status===0&&!(o.responseURL&&o.responseURL.indexOf("file:")===0)||setTimeout(a)},o.onabort=function(){o&&(I(new l("Request aborted",l.ECONNABORTED,A,o)),o=null)},o.onerror=function(){I(new l("Network Error",l.ERR_NETWORK,A,o)),o=null},o.ontimeout=function(){let f=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",d=A.transitional||mA;A.timeoutErrorMessage&&(f=A.timeoutErrorMessage),I(new l(f,d.clarifyTimeoutError?l.ETIMEDOUT:l.ECONNABORTED,A,o)),o=null},D.isStandardBrowserEnv){let Q=je(c)&&A.xsrfCookieName&&We.read(A.xsrfCookieName);Q&&i.set(A.xsrfHeaderName,Q)}r===void 0&&i.setContentType(null),"setRequestHeader"in o&&s.forEach(i.toJSON(),function(f,d){o.setRequestHeader(d,f)}),s.isUndefined(A.withCredentials)||(o.withCredentials=!!A.withCredentials),g&&g!=="json"&&(o.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&o.addEventListener("progress",_e(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&o.upload&&o.upload.addEventListener("progress",_e(A.onUploadProgress)),(A.cancelToken||A.signal)&&(n=Q=>{o&&(I(!Q||Q.type?new M(null,A,o):Q),o.abort(),o=null)},A.cancelToken&&A.cancelToken.subscribe(n),A.signal&&(A.signal.aborted?n():A.signal.addEventListener("abort",n)));let B=zA(c);if(B&&D.protocols.indexOf(B)===-1){I(new l("Unsupported protocol "+B+":",l.ERR_BAD_REQUEST,A));return}o.send(r||null)})};var XA={http:dA,xhr:Ve};s.forEach(XA,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var ze=A=>`- ${A}`,mI=A=>s.isFunction(A)||A===null||A===!1,wA={getAdapter:A=>{A=s.isArray(A)?A:[A];let{length:e}=A,t,I,r={};for(let i=0;i<e;i++){t=A[i];let g;if(I=t,!mI(t)&&(I=XA[(g=String(t)).toLowerCase()],I===void 0))throw new l(`Unknown adapter \'${g}\'`);if(I)break;r[g||"%23"+i]=I}if(!I){let i=Object.entries(r).map(([n,E])=>`adapter ${n} `+(E===!1?"is not supported by the environment":"is not available in the build")),g=e?i.length>1?`since :%0A`+i.map(ze).join(`%0A`):" "+ze(i[0]):"as no adapter specified";throw new l("There is no suitable adapter to dispatch the request "+g,"ERR_NOT_SUPPORT")}return I},adapters:XA};function vA(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new M(null,A)}function pA(A){return vA(A),A.headers=w.from(A.headers),A.data=tA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),wA.getAdapter(A.adapter||j.adapter)(A).then(function(I){return vA(A),I.data=tA.call(A,A.transformResponse,I),I.headers=w.from(I.headers),I},function(I){return IA(I)||(vA(A),I&&I.response&&(I.response.data=tA.call(A,A.transformResponse,I.response),I.response.headers=w.from(I.response.headers))),Promise.reject(I)})}var Xe=A=>A instanceof w?A.toJSON():A;function L(A,e){e=e||{};let t={};function I(C,o,c){return s.isPlainObject(C)&&s.isPlainObject(o)?s.merge.call({caseless:c},C,o):s.isPlainObject(o)?s.merge({},o):s.isArray(o)?o.slice():o}function r(C,o,c){if(s.isUndefined(o)){if(!s.isUndefined(C))return I(void 0,C,c)}else return I(C,o,c)}function i(C,o){if(!s.isUndefined(o))return I(void 0,o)}function g(C,o){if(s.isUndefined(o)){if(!s.isUndefined(C))return I(void 0,C)}else return I(void 0,o)}function n(C,o,c){if(c in e)return I(C,o);if(c in A)return I(void 0,C)}let E={url:i,method:i,data:i,baseURL:g,transformRequest:g,transformResponse:g,paramsSerializer:g,timeout:g,timeoutMessage:g,withCredentials:g,adapter:g,responseType:g,xsrfCookieName:g,xsrfHeaderName:g,onUploadProgress:g,onDownloadProgress:g,decompress:g,maxContentLength:g,maxBodyLength:g,beforeRedirect:g,transport:g,httpAgent:g,httpsAgent:g,cancelToken:g,socketPath:g,responseEncoding:g,validateStatus:n,headers:(C,o)=>r(Xe(C),Xe(o),!0)};return s.forEach(Object.keys(Object.assign({},A,e)),function(o){let c=E[o]||r,a=c(A[o],e[o],o);s.isUndefined(a)&&c!==n||(t[o]=a)}),t}var FA="1.6.0";var $A={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{$A[A]=function(I){return typeof I===A||"a"+(e<1?"n ":" ")+A}});var ve={};$A.transitional=function(e,t,I){function r(i,g){return"[Axios v"+FA+"] Transitional option \'"+i+"\'"+g+(I?". "+I:"")}return(i,g,n)=>{if(e===!1)throw new l(r(g," has been removed"+(t?" in "+t:"")),l.ERR_DEPRECATED);return t&&!ve[g]&&(ve[g]=!0,console.warn(r(g," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(i,g,n):!0}};function DI(A,e,t){if(typeof A!="object")throw new l("options must be an object",l.ERR_BAD_OPTION_VALUE);let I=Object.keys(A),r=I.length;for(;r-- >0;){let i=I[r],g=e[i];if(g){let n=A[i],E=n===void 0||g(n,i,A);if(E!==!0)throw new l("option "+i+" must be "+E,l.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new l("Unknown option "+i,l.ERR_BAD_OPTION)}}var SA={assertOptions:DI,validators:$A};var b=SA.validators,_=class{constructor(e){this.defaults=e,this.interceptors={request:new xA,response:new xA}}request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=L(this.defaults,t);let{transitional:I,paramsSerializer:r,headers:i}=t;I!==void 0&&SA.assertOptions(I,{silentJSONParsing:b.transitional(b.boolean),forcedJSONParsing:b.transitional(b.boolean),clarifyTimeoutError:b.transitional(b.boolean)},!1),r!=null&&(s.isFunction(r)?t.paramsSerializer={serialize:r}:SA.assertOptions(r,{encode:b.function,serialize:b.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let g=i&&s.merge(i.common,i[t.method]);i&&s.forEach(["delete","get","head","post","put","patch","common"],Q=>{delete i[Q]}),t.headers=w.concat(g,i);let n=[],E=!0;this.interceptors.request.forEach(function(f){typeof f.runWhen=="function"&&f.runWhen(t)===!1||(E=E&&f.synchronous,n.unshift(f.fulfilled,f.rejected))});let C=[];this.interceptors.response.forEach(function(f){C.push(f.fulfilled,f.rejected)});let o,c=0,a;if(!E){let Q=[pA.bind(this),void 0];for(Q.unshift.apply(Q,n),Q.push.apply(Q,C),a=Q.length,o=Promise.resolve(t);c<a;)o=o.then(Q[c++],Q[c++]);return o}a=n.length;let B=t;for(c=0;c<a;){let Q=n[c++],f=n[c++];try{B=Q(B)}catch(d){f.call(this,d);break}}try{o=pA.call(this,B)}catch(Q){return Promise.reject(Q)}for(c=0,a=C.length;c<a;)o=o.then(C[c++],C[c++]);return o}getUri(e){e=L(this.defaults,e);let t=rA(e.baseURL,e.url);return AA(t,e.params,e.paramsSerializer)}};s.forEach(["delete","get","head","options"],function(e){_.prototype[e]=function(t,I){return this.request(L(I||{},{method:e,url:t,data:(I||{}).data}))}});s.forEach(["post","put","patch"],function(e){function t(I){return function(i,g,n){return this.request(L(n||{},{method:e,headers:I?{"Content-Type":"multipart/form-data"}:{},url:i,data:g}))}}_.prototype[e]=t(),_.prototype[e+"Form"]=t(!0)});var iA=_;var Ae=class A{constructor(e){if(typeof e!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(i){t=i});let I=this;this.promise.then(r=>{if(!I._listeners)return;let i=I._listeners.length;for(;i-- >0;)I._listeners[i](r);I._listeners=null}),this.promise.then=r=>{let i,g=new Promise(n=>{I.subscribe(n),i=n}).then(r);return g.cancel=function(){I.unsubscribe(i)},g},e(function(i,g,n){I.reason||(I.reason=new M(i,g,n),t(I.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(e){if(this.reason){e(this.reason);return}this._listeners?this._listeners.push(e):this._listeners=[e]}unsubscribe(e){if(!this._listeners)return;let t=this._listeners.indexOf(e);t!==-1&&this._listeners.splice(t,1)}static source(){let e;return{token:new A(function(r){e=r}),cancel:e}}},$e=Ae;function ee(A){return function(t){return A.apply(null,t)}}function te(A){return s.isObject(A)&&A.isAxiosError===!0}var Ie={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(Ie).forEach(([A,e])=>{Ie[e]=A});var At=Ie;function et(A){let e=new iA(A),t=X(iA.prototype.request,e);return s.extend(t,iA.prototype,e,{allOwnKeys:!0}),s.extend(t,e,null,{allOwnKeys:!0}),t.create=function(r){return et(L(A,r))},t}var h=et(j);h.Axios=iA;h.CanceledError=M;h.CancelToken=$e;h.isCancel=IA;h.VERSION=FA;h.toFormData=J;h.AxiosError=l;h.Cancel=h.CanceledError;h.all=function(e){return Promise.all(e)};h.spread=ee;h.isAxiosError=te;h.mergeConfig=L;h.AxiosHeaders=w;h.formToJSON=A=>DA(s.isHTMLForm(A)?new FormData(A):A);h.getAdapter=wA.getAdapter;h.HttpStatusCode=At;h.default=h;var NA=h;var{Axios:Rg,AxiosError:Gg,CanceledError:Ug,isCancel:kg,CancelToken:Lg,VERSION:Og,all:Jg,Cancel:Mg,isAxiosError:bg,spread:Hg,toFormData:Yg,AxiosHeaders:qg,HttpStatusCode:Tg,formToJSON:Kg,getAdapter:xg,mergeConfig:Pg}=NA;var gA,O,ie,re={env:{emscripten_notify_memory_growth:function(A){ie=new Uint8Array(O.exports.memory.buffer)}}},RA=class{init(){return gA||(typeof fetch<"u"?gA=fetch("data:application/wasm;base64,"+tt).then(e=>e.arrayBuffer()).then(e=>WebAssembly.instantiate(e,re)).then(this._init):gA=WebAssembly.instantiate(Buffer.from(tt,"base64"),re).then(this._init),gA)}_init(e){O=e.instance,re.env.emscripten_notify_memory_growth(0)}decode(e,t=0){if(!O)throw new Error("ZSTDDecoder: Await .init() before decoding.");let I=e.byteLength,r=O.exports.malloc(I);ie.set(e,r),t=t||Number(O.exports.ZSTD_findDecompressedSize(r,I));let i=O.exports.malloc(t),g=O.exports.ZSTD_decompress(i,t,r,I),n=ie.slice(i,i+g);return O.exports.free(r),O.exports.free(i),n}},tt="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";var It=new RA,rt=!1;async function yI(A,e){let t=null;typeof A!="string"?t=A.href:A.startsWith("http")?t=A:t=`${e}/${A}`,t.endsWith(".js")&&(t=t.substring(0,t.length-3)),t.endsWith(".wasm")&&(t=t.substring(0,t.length-5));let I=`${t}.wasm`,r=await NA.get(`${I}.zst`,{responseType:"arraybuffer"});rt||(await It.init(),rt=!0);let g=It.decode(new Uint8Array(r.data)).buffer;return(await import(`${t}.js`)).default({wasmBinary:g})}var it=yI;var GA=new Map;async function wI(A,e){let t=A,I=A,r=null;return typeof A!="string"&&(t=new URL(A.href),I=t.href),GA.has(I)||GA.set(I,await it(t,e)),r=GA.get(I),r}var U=wI;var pI=new Map([["image/jpeg","JPEGImageIO"],["image/png","PNGImageIO"],["image/tiff","TIFFImageIO"],["image/x-ms-bmp","BMPImageIO"],["image/x-bmp","BMPImageIO"],["image/bmp","BMPImageIO"],["application/dicom","GDCMImageIO"]]),ge=pI;var FI=new Map([["bmp","BMPImageIO"],["BMP","BMPImageIO"],["dcm","GDCMImageIO"],["DCM","GDCMImageIO"],["gipl","GiplImageIO"],["gipl.gz","GiplImageIO"],["hdf5","HDF5ImageIO"],["jpg","JPEGImageIO"],["JPG","JPEGImageIO"],["jpeg","JPEGImageIO"],["JPEG","JPEGImageIO"],["iwi","WasmImageIO"],["iwi.cbor","WasmImageIO"],["iwi.cbor.zst","WasmZstdImageIO"],["lsm","LSMImageIO"],["mnc","MINCImageIO"],["MNC","MINCImageIO"],["mnc.gz","MINCImageIO"],["MNC.GZ","MINCImageIO"],["mnc2","MINCImageIO"],["MNC2","MINCImageIO"],["mgh","MGHImageIO"],["mgz","MGHImageIO"],["mgh.gz","MGHImageIO"],["mha","MetaImageIO"],["mhd","MetaImageIO"],["mrc","MRCImageIO"],["nia","NiftiImageIO"],["nii","NiftiImageIO"],["nii.gz","NiftiImageIO"],["hdr","NiftiImageIO"],["nrrd","NrrdImageIO"],["NRRD","NrrdImageIO"],["nhdr","NrrdImageIO"],["NHDR","NrrdImageIO"],["png","PNGImageIO"],["PNG","PNGImageIO"],["pic","BioRadImageIO"],["PIC","BioRadImageIO"],["tif","TIFFImageIO"],["TIF","TIFFImageIO"],["tiff","TIFFImageIO"],["TIFF","TIFFImageIO"],["vtk","VTKImageIO"],["VTK","VTKImageIO"],["isq","ScancoImageIO"],["ISQ","ScancoImageIO"],["fdf","FDFImageIO"],["FDF","FDFImageIO"]]),oe=FI;function SI(A){let e=A.slice((A.lastIndexOf(".")-1>>>0)+2);if(e.toLowerCase()==="gz"){let t=A.slice(0,-3).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="cbor"){let t=A.slice(0,-5).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="zst"){let t=A.slice(0,-10).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}else if(e.toLowerCase()==="zip"){let t=A.slice(0,-4).lastIndexOf(".");e=A.slice((t-1>>>0)+2)}return e}var UA=SI;var NI=["PNGImageIO","MetaImageIO","TIFFImageIO","NiftiImageIO","JPEGImageIO","NrrdImageIO","VTKImageIO","BMPImageIO","HDF5ImageIO","MINCImageIO","MRCImageIO","LSMImageIO","MGHImageIO","BioRadImageIO","GiplImageIO","GEAdwImageIO","GE4ImageIO","GE5ImageIO","GDCMImageIO","ScancoImageIO","FDFImageIO","WasmImageIO","WasmZstdImageIO"],kA=NI;var RI={TextFile:"InterfaceTextFile",BinaryFile:"InterfaceBinaryFile",TextStream:"InterfaceTextStream",BinaryStream:"InterfaceBinaryStream",Image:"InterfaceImage",Mesh:"InterfaceMesh",PolyData:"InterfacePolyData",JsonCompatible:"InterfaceJsonCompatible"},u=RI;var GI={Text:"Text",Binary:"Binary",Image:"Image",Mesh:"Mesh"},S=GI;var UI={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},p=UI;var kI={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},T=kI;function LI(A,e){let t=null;switch(A){case p.UInt8:{t=new Uint8Array(e);break}case p.Int8:{t=new Int8Array(e);break}case p.UInt16:{t=new Uint16Array(e);break}case p.Int16:{t=new Int16Array(e);break}case p.UInt32:{t=new Uint32Array(e);break}case p.Int32:{t=new Int32Array(e);break}case p.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case p.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case T.Float32:{t=new Float32Array(e);break}case T.Float64:{t=new Float64Array(e);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var m=LI;var nt=typeof globalThis.SharedArrayBuffer=="function",gt=new TextEncoder,ot=new TextDecoder("utf-8");function H(A,e){let t={flags:"r",encoding:"binary"},I=A.fs_open(e,t.flags),i=A.fs_stat(e).size,g=null;nt?g=new SharedArrayBuffer(i):g=new ArrayBuffer(i);let n=new Uint8Array(g);return A.fs_read(I,n,0,i,0),A.fs_close(I),n}function at(A,e,t){let I=null;nt?I=new SharedArrayBuffer(t):I=new ArrayBuffer(t);let r=new Uint8Array(I),i=new Uint8Array(A.HEAPU8.buffer,e,t);return r.set(i),r}function y(A,e,t,I){let r=0;return e!==null&&(r=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,I,e.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(e.buffer),r)),r}function V(A,e,t){let I=JSON.stringify(e),r=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,I.length]);A.writeAsciiToMemory(I,r,!1)}function N(A,e,t,I){let r=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,e,t]),i=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,e,t]),g=at(A,r,i);return m(I,g.buffer)}function ne(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e]),I=A.AsciiToString(t);return JSON.parse(I)}function OI(A,e,t,I){I!=null&&I.length>0&&I.forEach(function(C,o){var c;switch(C.type){case u.TextStream:{let a=gt.encode(C.data.data),B=y(A,a,o,0),Q={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${B}`};V(A,Q,o);break}case u.JsonCompatible:{let a=gt.encode(JSON.stringify(C.data)),B=y(A,a,o,0),Q={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${B}`};V(A,Q,o);break}case u.BinaryStream:{let a=C.data.data,B=y(A,a,o,0),Q={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${B}`};V(A,Q,o);break}case u.TextFile:{A.fs_writeFile(C.data.path,C.data.data);break}case u.BinaryFile:{A.fs_writeFile(C.data.path,C.data.data);break}case u.Image:{let a=C.data,B=y(A,a.data,o,0),Q=y(A,a.direction,o,1),f=typeof((c=a.metadata)===null||c===void 0?void 0:c.entries)<"u"?JSON.stringify(Array.from(a.metadata.entries())):"[]",d={imageType:a.imageType,name:a.name,origin:a.origin,spacing:a.spacing,direction:`data:application/vnd.itk.address,0:${Q}`,size:a.size,data:`data:application/vnd.itk.address,0:${B}`,metadata:f};V(A,d,o);break}case u.Mesh:{let a=C.data,B=y(A,a.points,o,0),Q=y(A,a.cells,o,1),f=y(A,a.pointData,o,2),d=y(A,a.cellData,o,3),F={meshType:a.meshType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${B}`,numberOfCells:a.numberOfCells,cells:`data:application/vnd.itk.address,0:${Q}`,cellBufferSize:a.cellBufferSize,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${f}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${d}`};V(A,F,o);break}case u.PolyData:{let a=C.data,B=y(A,a.points,o,0),Q=y(A,a.vertices,o,1),f=y(A,a.lines,o,2),d=y(A,a.polygons,o,3),F=y(A,a.triangleStrips,o,4),R=y(A,a.pointData,o,5),K=y(A,a.pointData,o,6),OA={polyDataType:a.polyDataType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${B}`,verticesBufferSize:a.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${Q}`,linesBufferSize:a.linesBufferSize,lines:`data:application/vnd.itk.address,0:${f}`,polygonsBufferSize:a.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${d}`,triangleStripsBufferSize:a.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${F}`,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${R}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${K}`};V(A,OA,o);break}case S.Text:{A.fs_writeFile(C.path,C.data);break}case S.Binary:{A.fs_writeFile(C.path,C.data);break}case S.Image:{let a=C.data,B={imageType:a.imageType,name:a.name,origin:a.origin,spacing:a.spacing,direction:"data:application/vnd.itk.path,data/direction.raw",size:a.size,data:"data:application/vnd.itk.path,data/data.raw"};if(A.fs_mkdirs(`${C.path}/data`),A.fs_writeFile(`${C.path}/index.json`,JSON.stringify(B)),a.data===null)throw Error("image.data is null");A.fs_writeFile(`${C.path}/data/data.raw`,new Uint8Array(a.data.buffer)),A.fs_writeFile(`${C.path}/data/direction.raw`,new Uint8Array(a.direction.buffer));break}case S.Mesh:{let a=C.data,B={meshType:a.meshType,name:a.name,numberOfPoints:a.numberOfPoints,points:"data:application/vnd.itk.path,data/points.raw",numberOfPointPixels:a.numberOfPointPixels,pointData:"data:application/vnd.itk.path,data/pointData.raw",numberOfCells:a.numberOfCells,cells:"data:application/vnd.itk.path,data/cells.raw",numberOfCellPixels:a.numberOfCellPixels,cellData:"data:application/vnd.itk.path,data/cellData.raw",cellBufferSize:a.cellBufferSize};if(A.fs_mkdirs(`${C.path}/data`),A.fs_writeFile(`${C.path}/index.json`,JSON.stringify(B)),B.numberOfPoints>0){if(a.points===null)throw Error("mesh.points is null");A.fs_writeFile(`${C.path}/data/points.raw`,new Uint8Array(a.points.buffer))}if(B.numberOfPointPixels>0){if(a.pointData===null)throw Error("mesh.pointData is null");A.fs_writeFile(`${C.path}/data/pointData.raw`,new Uint8Array(a.pointData.buffer))}if(B.numberOfCells>0){if(a.cells===null)throw Error("mesh.cells is null");A.fs_writeFile(`${C.path}/data/cells.raw`,new Uint8Array(a.cells.buffer))}if(B.numberOfCellPixels>0){if(a.cellData===null)throw Error("mesh.cellData is null");A.fs_writeFile(`${C.path}/data/cellData.raw`,new Uint8Array(a.cellData.buffer))}break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let r=A.stackSave(),i=0;try{i=A.callMain(e.slice())}catch(C){throw typeof C=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(C)):console.error("Build module in Debug mode for exception message information.")),C}finally{A.stackRestore(r)}let g=A.getModuleStdout(),n=A.getModuleStderr(),E=[];return t!=null&&t.length>0&&i===0&&t.forEach(function(C,o){let c=null;switch(C.type){case u.TextStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,o,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,o,0]),f=new Uint8Array(A.HEAPU8.buffer,B,Q);c={data:ot.decode(f)};break}case u.JsonCompatible:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,o,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,o,0]),f=new Uint8Array(A.HEAPU8.buffer,B,Q);c=JSON.parse(ot.decode(f));break}case u.BinaryStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,o,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,o,0]);c={data:at(A,B,Q)};break}case u.TextFile:{c={path:C.data.path,data:A.fs_readFile(C.data.path,{encoding:"utf8"})};break}case u.BinaryFile:{c={path:C.data.path,data:H(A,C.data.path)};break}case u.Image:{let B=ne(A,o);B.data=N(A,o,0,B.imageType.componentType),B.direction=N(A,o,1,T.Float64),B.metadata=new Map(B.metadata),c=B;break}case u.Mesh:{let B=ne(A,o);B.numberOfPoints>0?B.points=N(A,o,0,B.meshType.pointComponentType):B.points=m(B.meshType.pointComponentType,new ArrayBuffer(0)),B.numberOfCells>0?B.cells=N(A,o,1,B.meshType.cellComponentType):B.cells=m(B.meshType.cellComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=N(A,o,2,B.meshType.pointPixelComponentType):B.pointData=m(B.meshType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=N(A,o,3,B.meshType.cellPixelComponentType):B.cellData=m(B.meshType.cellPixelComponentType,new ArrayBuffer(0)),c=B;break}case u.PolyData:{let B=ne(A,o);B.numberOfPoints>0?B.points=N(A,o,0,T.Float32):B.points=new Float32Array,B.verticesBufferSize>0?B.vertices=N(A,o,1,p.UInt32):B.vertices=new Uint32Array,B.linesBufferSize>0?B.lines=N(A,o,2,p.UInt32):B.lines=new Uint32Array,B.polygonsBufferSize>0?B.polygons=N(A,o,3,p.UInt32):B.polygons=new Uint32Array,B.triangleStripsBufferSize>0?B.triangleStrips=N(A,o,4,p.UInt32):B.triangleStrips=new Uint32Array,B.numberOfPointPixels>0?B.pointData=N(A,o,5,B.polyDataType.pointPixelComponentType):B.pointData=m(B.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=N(A,o,6,B.polyDataType.cellPixelComponentType):B.cellData=m(B.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),c=B;break}case S.Text:{if(typeof C.path>"u")throw new Error("output.path not defined");c=A.fs_readFile(C.path,{encoding:"utf8"});break}case S.Binary:{if(typeof C.path>"u")throw new Error("output.path not defined");c=H(A,C.path);break}case S.Image:{if(typeof C.path>"u")throw new Error("output.path not defined");let B=A.fs_readFile(`${C.path}/index.json`,{encoding:"utf8"}),Q=JSON.parse(B),f=H(A,`${C.path}/data/data.raw`);Q.data=m(Q.imageType.componentType,f.buffer);let d=H(A,`${C.path}/data/direction.raw`);Q.direction=m(T.Float64,d.buffer),c=Q;break}case S.Mesh:{if(typeof C.path>"u")throw new Error("output.path not defined");let B=A.fs_readFile(`${C.path}/index.json`,{encoding:"utf8"}),Q=JSON.parse(B);if(Q.numberOfPoints>0){let f=H(A,`${C.path}/data/points.raw`);Q.points=m(Q.meshType.pointComponentType,f.buffer)}else Q.points=m(Q.meshType.pointComponentType,new ArrayBuffer(0));if(Q.numberOfPointPixels>0){let f=H(A,`${C.path}/data/pointData.raw`);Q.pointData=m(Q.meshType.pointPixelComponentType,f.buffer)}else Q.pointData=m(Q.meshType.pointPixelComponentType,new ArrayBuffer(0));if(Q.numberOfCells>0){let f=H(A,`${C.path}/data/cells.raw`);Q.cells=m(Q.meshType.cellComponentType,f.buffer)}else Q.cells=m(Q.meshType.cellComponentType,new ArrayBuffer(0));if(Q.numberOfCellPixels>0){let f=H(A,`${C.path}/data/cellData.raw`);Q.cellData=m(Q.meshType.cellPixelComponentType,f.buffer)}else Q.cellData=m(Q.meshType.cellPixelComponentType,new ArrayBuffer(0));c=Q;break}default:throw Error("Unsupported output InterfaceType")}let a={type:C.type,data:c};E.push(a)}),{returnValue:i,stdout:g,stderr:n,outputs:E}}var z=OI;var oA=function(A){return this instanceof oA?(this.v=A,this):new oA(A)},JI=function(A,e,t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var I=t.apply(A,e||[]),r,i=[];return r={},g("next"),g("throw"),g("return"),r[Symbol.asyncIterator]=function(){return this},r;function g(a){I[a]&&(r[a]=function(B){return new Promise(function(Q,f){i.push([a,B,Q,f])>1||n(a,B)})})}function n(a,B){try{E(I[a](B))}catch(Q){c(i[0][3],Q)}}function E(a){a.value instanceof oA?Promise.resolve(a.value.v).then(C,o):c(i[0][2],a)}function C(a){n("next",a)}function o(a){n("throw",a)}function c(a,B){a(B),i.shift(),i.length&&n(i[0][0],i[0][1])}},MI=function(A){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=A[Symbol.asyncIterator],t;return e?e.call(A):(A=typeof __values=="function"?__values(A):A[Symbol.iterator](),t={},I("next"),I("throw"),I("return"),t[Symbol.asyncIterator]=function(){return this},t);function I(i){t[i]=A[i]&&function(g){return new Promise(function(n,E){g=A[i](g),r(n,E,g.done,g.value)})}}function r(i,g,n,E){Promise.resolve(E).then(function(C){i({value:C,done:n})},g)}};function bI(A){return JI(this,arguments,function*(){for(let t=0;t<kA.length;t++){let I=kA[t]+"-read-image",r=yield oA(U(I,A.config.imageIOUrl));yield yield oA(r)}})}async function HI(A,e){var t,I;if(A.mimeType&&ge.has(A.mimeType)){let n=ge.get(A.mimeType)+e;return await U(n,A.config.imageIOUrl)}let r=UA(A.fileName);if(oe.has(r)){let n=oe.get(r)+e;return await U(n,A.config.imageIOUrl)}for(let n=0;n<kA.length;++n){let E=0;try{for(var i=(t=void 0,MI(bI(A))),g;g=await i.next(),!g.done;){let C=g.value;try{let{returnValue:o,outputs:c}=await z(C,A.args,A.outputs,A.inputs);if(o===0)return C}catch{}E++}}catch(C){t={error:C}}finally{try{g&&!g.done&&(I=i.return)&&await I.call(i)}finally{if(t)throw t.error}}}throw Error(`Could not find IO for: ${A.fileName}`)}var ae=HI;var YI=new Map([]),se=YI;var qI=new Map([["vtk","VTKPolyDataMeshIO"],["VTK","VTKPolyDataMeshIO"],["byu","BYUMeshIO"],["BYU","BYUMeshIO"],["fsa","FreeSurferAsciiMeshIO"],["FSA","FreeSurferAsciiMeshIO"],["fsb","FreeSurferBinaryMeshIO"],["FSB","FreeSurferBinaryMeshIO"],["obj","OBJMeshIO"],["OBJ","OBJMeshIO"],["off","OFFMeshIO"],["OFF","OFFMeshIO"],["stl","STLMeshIO"],["STL","STLMeshIO"],["swc","SWCMeshIO"],["SWC","SWCMeshIO"],["iwm","WasmMeshIO"],["iwm.cbor","WasmMeshIO"],["iwm.cbor.zst","WasmZstdMeshIO"]]),Ce=qI;var TI=["BYUMeshIO","FreeSurferAsciiMeshIO","FreeSurferBinaryMeshIO","OBJMeshIO","OFFMeshIO","STLMeshIO","SWCMeshIO","VTKPolyDataMeshIO","WasmMeshIO","WasmZstdMeshIO"],LA=TI;var nA=function(A){return this instanceof nA?(this.v=A,this):new nA(A)},KI=function(A,e,t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var I=t.apply(A,e||[]),r,i=[];return r={},g("next"),g("throw"),g("return"),r[Symbol.asyncIterator]=function(){return this},r;function g(a){I[a]&&(r[a]=function(B){return new Promise(function(Q,f){i.push([a,B,Q,f])>1||n(a,B)})})}function n(a,B){try{E(I[a](B))}catch(Q){c(i[0][3],Q)}}function E(a){a.value instanceof nA?Promise.resolve(a.value.v).then(C,o):c(i[0][2],a)}function C(a){n("next",a)}function o(a){n("throw",a)}function c(a,B){a(B),i.shift(),i.length&&n(i[0][0],i[0][1])}},xI=function(A){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var e=A[Symbol.asyncIterator],t;return e?e.call(A):(A=typeof __values=="function"?__values(A):A[Symbol.iterator](),t={},I("next"),I("throw"),I("return"),t[Symbol.asyncIterator]=function(){return this},t);function I(i){t[i]=A[i]&&function(g){return new Promise(function(n,E){g=A[i](g),r(n,E,g.done,g.value)})}}function r(i,g,n,E){Promise.resolve(E).then(function(C){i({value:C,done:n})},g)}};function PI(A){return KI(this,arguments,function*(){for(let t=0;t<LA.length;t++){let I=LA[t]+"-read-mesh",r=yield nA(U(I,A.config.meshIOUrl));yield yield nA(r)}})}async function WI(A,e){var t,I;if(A.mimeType&&se.has(A.mimeType)){let n=se.get(A.mimeType)+e;return await U(n,A.config.meshIOUrl)}let r=UA(A.fileName);if(Ce.has(r)){let n=Ce.get(r)+e;return await U(n,A.config.meshIOUrl)}for(let n=0;n<LA.length;++n){let E=0;try{for(var i=(t=void 0,xI(PI(A))),g;g=await i.next(),!g.done;){let C=g.value;try{let{returnValue:o,outputs:c}=await z(C,A.args,A.outputs,A.inputs);if(o===0)return C}catch{}E++}}catch(C){t={error:C}}finally{try{g&&!g.done&&(I=i.return)&&await I.call(i)}finally{if(t)throw t.error}}}throw Error(`Could not find IO for: ${A.fileName}`)}var Be=WI;var jI=typeof globalThis.SharedArrayBuffer<"u";function ZI(A){if(A==null)return[];let e=[];for(let t=0;t<A.length;t++){let I=_I(A[t]);I!==null&&e.push(I)}return e}function _I(A){if(A==null)return null;let e=null;return A.buffer!==void 0?e=A.buffer:A.byteLength!==void 0&&(e=A),jI&&e instanceof SharedArrayBuffer?null:e}var st=ZI;function VI(A){return[A.data,A.direction]}var Qe=VI;function zI(A){return[A.points,A.pointData,A.cells,A.cellData]}var Ee=zI;function XI(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var Ct=XI;async function vI(A,e,t,I){let r=z(A,e,t,I),i=[];return r.outputs&&r.outputs.forEach(function(g){if(g.type===u.BinaryStream||g.type===u.BinaryFile){let n=g.data;i.push(n)}else if(g.type===u.Image){let n=g.data;i.push(...Qe(n))}else if(g.type===u.Mesh){let n=g.data;i.push(...Ee(n))}else if(g.type===u.PolyData){let n=g.data;i.push(...Ct(n))}else if(g.type===S.Binary){let n=g.data;i.push(n)}else if(g.type===S.Image){let n=g.data;i.push(...Qe(n))}else if(g.type===S.Mesh){let n=g.data;i.push(...Ee(n))}}),bA(r,st(i))}var Y=vI;var $I={meshToPolyData:async function(A,e,t,I){let r=await U("mesh-to-polydata",A.meshIOUrl);return Y(r,e,t,I)},polyDataToMesh:async function(A,e,t,I){let r=await U("polydata-to-mesh",A.meshIOUrl);return Y(r,e,t,I)},readImage:async function(A,e,t,I,r,i){let g=await ae({fileName:t,mimeType:e,config:A,args:I,outputs:r,inputs:i},"-read-image");return Y(g,I,r,i)},writeImage:async function(A,e,t,I,r,i){let g=await ae({fileName:t,mimeType:e,config:A,args:I,outputs:r,inputs:i},"-write-image");return Y(g,I,r,i)},readMesh:async function(A,e,t,I,r,i){let g=await Be({fileName:t,mimeType:e,config:A,args:I,outputs:r,inputs:i},"-read-mesh");return Y(g,I,r,i)},writeMesh:async function(A,e,t,I,r,i){let g=await Be({fileName:t,mimeType:e,config:A,args:I,outputs:r,inputs:i},"-write-mesh");return Y(g,I,r,i)},runPipeline:async function(A,e,t,I,r,i){let g=typeof A[t]>"u"?t:A[t],n=await U(e,g);return Y(n,I,r,i)}};EA($I);%0A/*! Bundled license information:%0A%0Acomlink/dist/esm/comlink.mjs:%0A  (**%0A   * @license%0A   * Copyright 2019 Google LLC%0A   * SPDX-License-Identifier: Apache-2.0%0A   *)%0A*/%0A';Ut(Nt);export{he as byuReadMesh,ye as byuWriteMesh,we as freeSurferAsciiReadMesh,De as freeSurferAsciiWriteMesh,be as freeSurferBinaryReadMesh,Fe as freeSurferBinaryWriteMesh,Q as getPipelineWorkerUrl,E as getPipelinesBaseUrl,le as objReadMesh,ge as objWriteMesh,pe as offReadMesh,ce as offWriteMesh,Gi as readMesh,Ut as setPipelineWorkerUrl,Ps as setPipelinesBaseUrl,ue as stlReadMesh,fe as stlWriteMesh,Ee as swcReadMesh,Qe as swcWriteMesh,se as vtkPolyDataReadMesh,Ie as vtkPolyDataWriteMesh,Be as wasmReadMesh,Ce as wasmWriteMesh,me as wasmZstdReadMesh,de as wasmZstdWriteMesh,Hi as wasmZtdReadMesh,qi as wasmZtdWriteMesh,Li as writeMesh};
/*! Bundled license information:

comlink/dist/esm/comlink.mjs:
  (**
   * @license
   * Copyright 2019 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   *)
*/
"""
+default_config = JsPackageConfig(default_js_module)
+js_package = JsPackage(default_config)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_read_mesh_async.py
new file mode 100644
index 000000000..2fa547304
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def obj_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.objReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_write_mesh_async.py
new file mode 100644
index 000000000..433e9fbcb
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/obj_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def obj_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.objWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_read_mesh_async.py
new file mode 100644
index 000000000..3b2c38f39
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def off_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.offReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_write_mesh_async.py
new file mode 100644
index 000000000..e20bd0de1
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/off_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def off_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.offWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_read_mesh_async.py
new file mode 100644
index 000000000..0cdd11fff
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def stl_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.stlReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_write_mesh_async.py
new file mode 100644
index 000000000..35d77f8c6
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/stl_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def stl_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.stlWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_read_mesh_async.py
new file mode 100644
index 000000000..62e898315
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def swc_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.swcReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_write_mesh_async.py
new file mode 100644
index 000000000..d10b28af7
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/swc_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def swc_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.swcWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_read_mesh_async.py
new file mode 100644
index 000000000..927c36bd0
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def vtk_poly_data_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.vtkPolyDataReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_write_mesh_async.py
new file mode 100644
index 000000000..5fe9631e1
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/vtk_poly_data_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def vtk_poly_data_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.vtkPolyDataWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_read_mesh_async.py
new file mode 100644
index 000000000..c60af46e3
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def wasm_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.wasmReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_write_mesh_async.py
new file mode 100644
index 000000000..da3f40d4f
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def wasm_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.wasmWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_read_mesh_async.py
new file mode 100644
index 000000000..6bf589bf8
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def wasm_zstd_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.wasmZstdReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_write_mesh_async.py
new file mode 100644
index 000000000..4c5ab0f6a
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_zstd_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def wasm_zstd_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.wasmZstdWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_read_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_read_mesh_async.py
new file mode 100644
index 000000000..4b9ffd3e4
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_read_mesh_async.py
@@ -0,0 +1,60 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    BinaryFile,
+    Mesh,
+)
+
+async def wasm_ztd_read_mesh_async(
+    serialized_mesh: os.PathLike,
+    information_only: bool = False,
+) -> Tuple[Any, Mesh]:
+    """Read a mesh file format and convert it to the itk-wasm file format
+
+    :param serialized_mesh: Input mesh serialized in the file format
+    :type  serialized_mesh: os.PathLike
+
+    :param information_only: Only read image metadata -- do not read pixel data.
+    :type  information_only: bool
+
+    :return: Whether the input could be read. If false, the output mesh is not valid.
+    :rtype:  Any
+
+    :return: Output mesh
+    :rtype:  Mesh
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+
+    outputs = await js_module.wasmZtdReadMesh(web_worker, to_js(BinaryFile(serialized_mesh)), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_write_mesh_async.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_write_mesh_async.py
new file mode 100644
index 000000000..3b6344878
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/itkwasm_mesh_io_emscripten/wasm_ztd_write_mesh_async.py
@@ -0,0 +1,73 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from .js_package import js_package
+
+from itkwasm.pyodide import (
+    to_js,
+    to_py,
+    js_resources
+)
+from itkwasm import (
+    InterfaceTypes,
+    Mesh,
+    BinaryFile,
+)
+
+async def wasm_ztd_write_mesh_async(
+    mesh: Mesh,
+    serialized_mesh: str,
+    information_only: bool = False,
+    use_compression: bool = False,
+    binary_file_type: bool = False,
+) -> Tuple[Any]:
+    """Write an itk-wasm file format converted to an mesh file format
+
+    :param mesh: Input mesh
+    :type  mesh: Mesh
+
+    :param serialized_mesh: Output mesh
+    :type  serialized_mesh: str
+
+    :param information_only: Only write image metadata -- do not write pixel data.
+    :type  information_only: bool
+
+    :param use_compression: Use compression in the written file, if supported
+    :type  use_compression: bool
+
+    :param binary_file_type: Use a binary file type in the written file, if supported
+    :type  binary_file_type: bool
+
+    :return: Whether the input could be written. If false, the output mesh is not valid.
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if information_only:
+        kwargs["informationOnly"] = to_js(information_only)
+    if use_compression:
+        kwargs["useCompression"] = to_js(use_compression)
+    if binary_file_type:
+        kwargs["binaryFileType"] = to_js(binary_file_type)
+
+    outputs = await js_module.wasmZtdWriteMesh(web_worker, to_js(mesh), to_js(serialized_mesh), **kwargs)
+
+    output_web_worker = None
+    output_list = []
+    outputs_object_map = outputs.as_object_map()
+    for output_name in outputs.object_keys():
+        if output_name == 'webWorker':
+            output_web_worker = outputs_object_map[output_name]
+        else:
+            output_list.append(to_py(outputs_object_map[output_name]))
+
+    js_resources.web_worker = output_web_worker
+
+    if len(output_list) == 1:
+        return output_list[0]
+    return tuple(output_list)
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/pyproject.toml b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/pyproject.toml
new file mode 100644
index 000000000..1e7d7ccbc
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/pyproject.toml
@@ -0,0 +1,73 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "itkwasm-mesh-io-emscripten"
+readme = "README.md"
+license = "Apache-2.0"
+dynamic = ["version"]
+description = "Input and output for scientific and medical image file formats."
+classifiers = [
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python",
+  "Programming Language :: C++",
+  "Environment :: WebAssembly",
+  "Environment :: WebAssembly :: Emscripten",
+  "Environment :: WebAssembly :: WASI",
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+keywords = [
+  "itkwasm",
+  "webassembly",
+  "emscripten",
+]
+
+requires-python = ">=3.8"
+dependencies = [
+    "itkwasm >= 1.0.b145",
+]
+
+[tool.hatch.version]
+path = "itkwasm_mesh_io_emscripten/_version.py"
+
+[tool.hatch.envs.default]
+dependencies = [
+  "pytest",
+  "pytest-pyodide",
+]
+
+[project.urls]
+Home = "https://github.com/InsightSoftwareConsortium/itk-wasm"
+Source = "https://github.com/InsightSoftwareConsortium/itk-wasm"
+
+[tool.hatch.envs.default.scripts]
+test = [
+  "hatch build -t wheel",
+  "pytest --dist-dir=./dist --rt=chrome",
+]
+download-pyodide = [
+  "curl -L https://github.com/pyodide/pyodide/releases/download/0.24.1/pyodide-0.24.1.tar.bz2 -o pyodide.tar.bz2",
+  "tar xjf pyodide.tar.bz2",
+  "rm -rf dist pyodide.tar.bz2",
+  "mv pyodide dist",
+]
+serve = [
+  "hatch build -t wheel",
+  'echo "\nVisit http://localhost:8877/console.html\n"',
+  "python -m http.server --directory=./dist 8877",
+]
+
+
+[tool.hatch.build]
+exclude = [
+  "/examples",
+]
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/__init__.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/fixtures.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/fixtures.py
new file mode 100644
index 000000000..b54af232e
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/fixtures.py
@@ -0,0 +1,28 @@
+import pytest
+import sys
+
+if sys.version_info < (3,10):
+    pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
+
+from pytest_pyodide import run_in_pyodide
+
+from itkwasm_image_io_emscripten import __version__ as test_package_version
+
+@pytest.fixture
+def package_wheel():
+    return f"itkwasm_image_io_emscripten-{test_package_version}-py3-none-any.whl"
+
+@pytest.fixture
+def input_data():
+    from pathlib import Path
+    input_base_path = Path('..', '..', 'test', 'data')
+    test_files = [
+        Path('input') / 'cthead1.png',
+        Path('input') / 'biorad.pic',
+        Path('input') / 'brainweb165a10f17.mha',
+    ]
+    data = {}
+    for f in test_files:
+        with open(input_base_path / f, 'rb') as fp:
+            data[str(f.name)] = fp.read()
+    return data
\ No newline at end of file
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/test_itkwasm_mesh_io.py b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/test_itkwasm_mesh_io.py
new file mode 100644
index 000000000..094b4b8c9
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-emscripten/test/test_itkwasm_mesh_io.py
@@ -0,0 +1,20 @@
+import pytest
+import sys
+
+if sys.version_info < (3,10):
+    pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
+
+from pytest_pyodide import run_in_pyodide
+
+from itkwasm_mesh_io_emscripten import __version__ as test_package_version
+
+@pytest.fixture
+def package_wheel():
+    return f"itkwasm_mesh_io_emscripten-{test_package_version}-py3-none-any.whl"
+
+@run_in_pyodide(packages=['micropip'])
+async def test_example(selenium, package_wheel):
+    import micropip
+    await micropip.install(package_wheel)
+
+    # Write your test code here
diff --git a/packages/mesh-io/python/itkwasm-mesh-io-wasi/.gitignore b/packages/mesh-io/python/itkwasm-mesh-io-wasi/.gitignore
new file mode 100644
index 000000000..123166809
--- /dev/null
+++ b/packages/mesh-io/python/itkwasm-mesh-io-wasi/.gitignore
@@ -0,0 +1 @@
+itkwasm_mesh_io_wasi/wasm_modules/