diff --git a/packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-function-module.js b/packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-function-module.js
index 9ee279068..f13cfb62f 100644
--- a/packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-function-module.js
+++ b/packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-function-module.js
@@ -79,7 +79,16 @@ from itkwasm import (
           addKwargs += `        kwargs["${camelCase(parameter.name)}"] = to_js(${snakeCase(parameter.name)})\n`
       }
     } else {
-      addKwargs += `    if ${snakeCase(parameter.name)}:\n`
+      // Use a presence check (not truthiness) for numeric scalar options so that valid falsy values --
+      // notably 0 for an integer/float option -- are still forwarded. BOOL, list, and TEXT options keep the
+      // truthiness guard (an explicit False, an empty list, or an unset string is a no-op).
+      const numericScalar =
+        parameter.itemsExpectedMax <= 1 &&
+        parameter.type !== 'BOOL' &&
+        !parameter.type.startsWith('TEXT')
+      addKwargs += numericScalar
+        ? `    if ${snakeCase(parameter.name)} is not None:\n`
+        : `    if ${snakeCase(parameter.name)}:\n`
       addKwargs += `        kwargs["${camelCase(parameter.name)}"] = to_js(${snakeCase(parameter.name)})\n`
     }
   })
diff --git a/packages/core/typescript/itk-wasm/src/bindgen/python/wasi/wasi-function-module.js b/packages/core/typescript/itk-wasm/src/bindgen/python/wasi/wasi-function-module.js
index c7b86779d..d69d249bd 100644
--- a/packages/core/typescript/itk-wasm/src/bindgen/python/wasi/wasi-function-module.js
+++ b/packages/core/typescript/itk-wasm/src/bindgen/python/wasi/wasi-function-module.js
@@ -232,7 +232,12 @@ from itkwasm import (
           args += `        input_count += 1\n`
         }
       } else {
-        args += `    if ${snake}:\n`
+        // Use a presence check (not truthiness) for numeric scalar options so that valid falsy values --
+        // notably 0 for an integer/float option -- are still forwarded to the pipeline. TEXT options keep the
+        // truthiness guard so an unset (empty-string) option is not forwarded.
+        args += parameter.type.startsWith('TEXT')
+          ? `    if ${snake}:\n`
+          : `    if ${snake} is not None:\n`
         if (parameter.type.startsWith('TEXT:{')) {
           const choices = parameter.type.split('{')[1].split('}')[0].split(', ')
           args += `        if ${snake} not in (${choices.map((c) => `'${c}'`).join(',')}):\n`
diff --git a/packages/core/typescript/itk-wasm/src/bindgen/typescript/function-module.js b/packages/core/typescript/itk-wasm/src/bindgen/typescript/function-module.js
index 4d61c3d6f..747a6d884 100644
--- a/packages/core/typescript/itk-wasm/src/bindgen/typescript/function-module.js
+++ b/packages/core/typescript/itk-wasm/src/bindgen/typescript/function-module.js
@@ -429,7 +429,9 @@ function functionModule(
       return
     }
     const camel = camelCase(parameter.name)
-    functionContent += `  if (options.${camel}) {\n`
+    // Use a presence check (not truthiness) so that valid falsy values -- notably 0 for a numeric option --
+    // are still forwarded. BOOL options are additionally guarded below, so an explicit `false` is a no-op.
+    functionContent += `  if (typeof options.${camel} !== "undefined") {\n`
     if (parameter.type === 'BOOL') {
       functionContent += `    options.${camel} && args.push('--${parameter.name}')\n`
     } else if (parameter.itemsExpectedMax > 1) {
diff --git a/packages/core/typescript/itk-wasm/src/cli/bindgen.js b/packages/core/typescript/itk-wasm/src/cli/bindgen.js
index 9e2e3ead0..9359891e3 100644
--- a/packages/core/typescript/itk-wasm/src/cli/bindgen.js
+++ b/packages/core/typescript/itk-wasm/src/cli/bindgen.js
@@ -37,6 +37,28 @@ function bindgen(options) {
     (binary) => !path.basename(binary).startsWith('lib')
   )
 
+  // Honor an optional, opt-in exclude list so build-only helper executables (e.g. self-contained
+  // test-input generators used by C++ CTests) are not emitted as public language bindings. The list is
+  // configured as string pipeline names under "itk-wasm.bindgen-exclude" in the package's package.json,
+  // where each name matches a binary's stem after stripping the toolchain and .wasm suffixes
+  // (e.g. "foo-generate-inputs" matches both "foo-generate-inputs.wasm" and "foo-generate-inputs.wasi.wasm").
+  let bindgenExclude = []
+  try {
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'))
+    bindgenExclude = packageJson['itk-wasm']?.['bindgen-exclude'] ?? []
+  } catch (err) {
+    // No package.json or no config in the current directory: nothing to exclude.
+  }
+  if (bindgenExclude.length > 0) {
+    filteredWasmBinaries = filteredWasmBinaries.filter((binary) => {
+      const stem = path
+        .basename(binary)
+        .replace(/\.wasm$/, '')
+        .replace(/\.(wasi|emscripten)$/, '')
+      return !bindgenExclude.includes(stem)
+    })
+  }
+
   switch (iface) {
     case 'typescript':
       typescriptBindgen(outputDir, buildDir, filteredWasmBinaries, options)
diff --git a/packages/downsample/CMakeLists.txt b/packages/downsample/CMakeLists.txt
index ad2ac5421..69ca2f36d 100644
--- a/packages/downsample/CMakeLists.txt
+++ b/packages/downsample/CMakeLists.txt
@@ -13,6 +13,7 @@ elseif(WASI)
 else()
   set(io_components
     ITKImageIO
+    ITKTransformIO
     )
 endif()
 
@@ -21,12 +22,34 @@ find_package(ITK REQUIRED
    WebAssemblyInterface
    ITKSmoothing
    ITKImageGrid
+   ITKTransform
    GenericLabelInterpolator
    ${io_components}
  )
 include(${ITK_USE_FILE})
 
-foreach(pipeline downsample downsample-sigma gaussian-kernel-radius downsample-bin-shrink downsample-label-image)
+set(pipelines
+  downsample
+  downsample-sigma
+  gaussian-kernel-radius
+  downsample-bin-shrink
+  downsample-label-image
+  resample-bounding-box
+  )
+
+# resample-bounding-box-generate-inputs fabricates the self-contained inputs (fixed image, moving image,
+# transform) for the resample-bounding-box C++ CTests, and resample-bounding-box-test is an in-process unit
+# test that asserts the computed regions directly. Both run under the WASI/native toolchains and are
+# deliberately NOT built for Emscripten so they never leak into the browser/Node bindings (TypeScript bindgen
+# scans the Emscripten build). They ARE present in the WASI build, however, which the Python bindgen scans --
+# neither is an itk-wasm pipeline, so both MUST also be listed under "itk-wasm.bindgen-exclude" in package.json
+# or Python bindgen crashes trying to read their (empty) interface JSON. The real, public pipeline is
+# resample-bounding-box.
+if(NOT EMSCRIPTEN)
+  list(APPEND pipelines resample-bounding-box-generate-inputs resample-bounding-box-test)
+endif()
+
+foreach(pipeline ${pipelines})
   add_executable(${pipeline} ${pipeline}.cxx)
   target_link_libraries(${pipeline} PUBLIC ${ITK_LIBRARIES})
   target_include_directories(${pipeline} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
@@ -69,3 +92,74 @@ add_test(NAME downsample-label-image
     ${CMAKE_CURRENT_BINARY_DIR}/cthead1_downsampled_label_image.png
     --shrink-factors 2 2
     )
+
+# Generate the resample-bounding-box inputs (fixed image, moving image, transform), then feed them
+# to the pipeline. The pipeline's positional argument order (transform, fixed, moving, output) matches
+# the option declaration order in resample-bounding-box.cxx. The generator is only built for the
+# WASI/native toolchains (see above), so these tests are scoped to those toolchains as well; the
+# in-memory Node/Python bindings exercise the pipeline for the Emscripten target instead.
+if(NOT EMSCRIPTEN)
+  add_test(NAME resample-bounding-box-generate-inputs
+    COMMAND resample-bounding-box-generate-inputs
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-transform.iwt
+      )
+
+  add_test(NAME resample-bounding-box
+    COMMAND resample-bounding-box
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-transform.iwt
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-output.json
+      --padding 1
+      )
+
+  set_tests_properties(resample-bounding-box PROPERTIES DEPENDS resample-bounding-box-generate-inputs)
+
+  # 3D translation: generate the 3D inputs, then run the pipeline end-to-end through the dimension dispatch.
+  add_test(NAME resample-bounding-box-generate-inputs-3d
+    COMMAND resample-bounding-box-generate-inputs
+      --case 3d-translation
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-transform.iwt
+      )
+
+  add_test(NAME resample-bounding-box-3d
+    COMMAND resample-bounding-box
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-transform.iwt
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-3d-output.json
+      --padding 1
+      )
+
+  set_tests_properties(resample-bounding-box-3d PROPERTIES DEPENDS resample-bounding-box-generate-inputs-3d)
+
+  # 2D affine rotation: transformed grid corners are non-axis-aligned, stressing full-boundary sampling.
+  add_test(NAME resample-bounding-box-generate-inputs-rotation
+    COMMAND resample-bounding-box-generate-inputs
+      --case 2d-rotation
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-transform.iwt
+      )
+
+  add_test(NAME resample-bounding-box-rotation
+    COMMAND resample-bounding-box
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-transform.iwt
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-fixed.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-moving.iwi
+      ${CMAKE_CURRENT_BINARY_DIR}/rbb-rot-output.json
+      --padding 1
+      )
+
+  set_tests_properties(resample-bounding-box-rotation PROPERTIES DEPENDS resample-bounding-box-generate-inputs-rotation)
+
+  # In-process unit test: asserts the exact regions for the 2D/3D/rotation cases and the Phase-04 hardening
+  # (full-boundary sampling, symmetric padding, padding-independent corners, degenerate axis, instance reuse).
+  add_test(NAME resample-bounding-box-test
+    COMMAND resample-bounding-box-test
+      )
+endif()
diff --git a/packages/downsample/docs/resample-bounding-box.md b/packages/downsample/docs/resample-bounding-box.md
new file mode 100644
index 000000000..ea1365979
--- /dev/null
+++ b/packages/downsample/docs/resample-bounding-box.md
@@ -0,0 +1,158 @@
+---
+type: reference
+title: Resample Bounding Box Pipeline
+created: 2026-07-02
+tags:
+  - itk-wasm
+  - resampling
+  - bounding-box
+  - transform
+related:
+  - '[[downsample]]'
+  - '[[affine-ops]]'
+---
+
+# Resample Bounding Box Pipeline
+
+`resample-bounding-box` computes the padded region of a **moving** image that is needed to resample a **fixed**
+image's grid through a spatial transform — *without touching a single pixel*. It reads only image metadata
+(size, spacing, origin, direction), so both images may be supplied with empty data buffers. The result is a small
+JSON object describing exactly which sub-region of the moving image a caller must fetch before performing the real,
+pixel-level resample (for example with [[downsample]] or an affine warp built from [[affine-ops]]).
+
+The pipeline is part of the `@itk-wasm/downsample` / `itkwasm-downsample` packages and runs identically in C++
+(WASI/native CTest), TypeScript (browser/Node), and Python.
+
+## Motivation
+
+Resampling a fixed grid into a moving image only ever reads moving-image samples inside the transformed footprint
+of the fixed grid. When the moving image is large (or remote, or chunked), materializing all of it just to resample
+a small overlapping region is wasteful. `resample-bounding-box` answers the question **"which moving-image indices
+will the resample actually read?"** using arithmetic on metadata alone, so a caller can fetch only that block.
+
+## Inputs
+
+Positional arguments are, in order, `transform`, `fixed`, `moving`, `bounding-box` (output), matching the CLI and
+the generated bindings.
+
+| Input | Type | Notes |
+| --- | --- | --- |
+| `transform` | `INPUT_TRANSFORM` | Spatial transform mapping **fixed**-image physical points into **moving**-image physical space. Any single, non-composite parameterization at dimension 2, 3, or 4 (e.g. `TranslationTransform`, `AffineTransform`). Read at double precision regardless of stored precision. |
+| `fixed` | `INPUT_IMAGE` | Fixed image whose grid is resampled. **Metadata only** — the pixel buffer is never dereferenced and may be empty. |
+| `moving` | `INPUT_IMAGE` | Moving image to be sampled. **Metadata only** — buffer may be empty. |
+| `--padding` | `int`, default `1` | Pixels of padding added per side (symmetrically). The default of `1` covers linear interpolation, which reads one neighbor beyond the continuous-index bound. Use `0` for the tight region, or a larger value for wider-support interpolators. |
+
+Both images must share the transform's dimension. The pipeline dispatches on the transform dimension itself, so a
+2D transform expects 2D images, a 3D transform 3D images, and so on.
+
+### Metadata-only contract
+
+The fixed and moving pixel buffers are **never** read. In the bindings this means the caller can construct images
+whose `data` is an empty array of the correct component type and still receive a correct region. This is the whole
+point: describe two images and a transform with a few numbers, learn precisely which moving-image block to fetch,
+and only then move real pixels.
+
+## Algorithm
+
+For a fixed image of dimension *N*:
+
+1. **Sample selection.** Ask the transform whether it is linear (`itk::Transform::IsLinear()`, i.e.
+   `GetTransformCategory() == Linear` — true for translation, rigid, similarity, and affine transforms).
+   - **Linear (fast path).** Sample only the `2^N` grid *corners* (4 in 2D, 8 in 3D, …). A linear map sends the
+     fixed rectangle to a convex region, so its axis-aligned bound is already attained at the transformed corners —
+     the corners give the exact same box as the full boundary would, at `2^N` transforms independent of image size.
+   - **Nonlinear.** Enumerate every *boundary* pixel of the fixed grid — every pixel with at least one index
+     component equal to `0` or `size_d - 1` (all faces and edges, not merely the corners). Interior pixels are
+     skipped efficiently (the fastest axis is fast-forwarded to its last column), so the cost is proportional to the
+     number of boundary pixels, not the total pixel count.
+2. **Transform.** Map each sampled point's physical location (corners on the linear fast path, boundary pixels
+   otherwise) through the transform into moving-image physical space, and convert to a continuous index in the
+   moving image (`TransformPhysicalPointToContinuousIndex`). All math is done at double precision.
+3. **Bounding box.** Accumulate the per-axis min/max of the transformed physical points (`corners`) and of the
+   moving-image continuous indices.
+4. **Moving index region.** Convert the continuous-index bounds to an integer region: `floor` the min and `ceil`
+   the max per axis.
+5. **Padding.** Expand the integer region outward by `--padding` on every side (`start -= padding`,
+   `end += padding`). The resulting per-axis size is clamped to a minimum of `0` (never negative).
+
+### Corner fast path vs. full-boundary sampling
+
+For a **linear** transform (translation, rigid, similarity, affine — rotation, scale, shear) the image of the fixed
+rectangle is convex, so its axis-aligned bound is already achieved at the `2^N` transformed corners. The pipeline
+detects this via `itk::Transform::IsLinear()` and samples **only the corners** — a `2^N`-point computation
+independent of image size, and provably identical to what a full-boundary walk would return.
+
+Enumerating the entire boundary is required only for **nonlinear** transforms (e.g. B-spline, displacement field),
+where an interior edge pixel can map *outside* the hull of the transformed corners; sampling only the corners would
+then *under-bound* the region and the later resample would read outside the fetched block. The pipeline therefore
+walks the full boundary whenever the transform is not linear. (The C++ unit test covers both paths: it asserts the
+linear cases sample exactly `2^N` corners yet reproduce the same region a boundary walk gives, and includes a
+nonlinear "bulge" transform whose right-edge midpoint maps beyond the transformed corners — confirming the full
+boundary is walked, and matters, precisely when the transform is nonlinear.)
+
+### Edge cases
+
+- A **degenerate fixed image** with any zero-length axis has no boundary pixels; the pipeline reports an all-zero,
+  empty region rather than producing garbage indices.
+- **Negative effective sizes** (e.g. a large negative `--padding`) are clamped so `paddedSize` is never negative.
+- `padding` is applied **symmetrically** per side, and the unpadded `corners` are the tight transformed-point
+  extremes **regardless** of the padding value.
+
+## Output JSON schema
+
+The `bounding-box` output is a single JSON object (`OUTPUT_JSON`). All arrays are length *N* (the image
+dimension), ordered fastest-axis-first (x, y, z, …).
+
+```json
+{
+  "paddedStartIndex": [int, ...],
+  "paddedSize": [uint, ...],
+  "paddedCorners": { "min": [double, ...], "max": [double, ...] },
+  "corners":       { "min": [double, ...], "max": [double, ...] }
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `paddedStartIndex` | Integer start index, **in the moving image**, of the region to fetch (padding included). May be negative if the transformed grid extends past the moving-image origin. |
+| `paddedSize` | Integer size, in moving-image pixels, of the region to fetch. Clamped to ≥ 0. |
+| `paddedCorners.min` / `.max` | Physical-space coordinates of the padded region's start index and inclusive-end index (from the moving-image grid). |
+| `corners.min` / `.max` | The **tight** (unpadded) transformed-point extremes in moving-image physical space. Padding-independent. |
+
+### Worked example (2D translation)
+
+Fixed `16×16`, spacing `(2, 2)`, origin `(10, 20)`; moving `64×64`, spacing `(1, 1)`, origin `(0, 0)`;
+translation `(10, 5)`; `--padding 1`:
+
+```json
+{"paddedStartIndex":[19,24],"paddedSize":[33,33],"paddedCorners":{"min":[19,24],"max":[51,56]},"corners":{"min":[20,25],"max":[50,55]}}
+```
+
+The output is compact (no whitespace). The `corners` / `paddedCorners` values are JSON numbers of type *double*, but
+an integer-valued coordinate is emitted without a trailing `.0` (e.g. `19`, not `19.0`) — the value is identical and
+every binding parses it as a floating-point number. A non-integer coordinate keeps its fraction at full precision:
+the 2D affine rotation below yields, for example, `"corners":{"min":[9.2,5.200000000000001],"max":[29.799999999999997,23.800000000000004]}`.
+
+The tight corners `[20,25]–[50,55]` are the translated fixed grid; padding 1 grows the integer region outward by
+one pixel per side. A 3D translation and a 2D affine rotation (non-axis-aligned corners `[9.2,5.2]–[29.8,23.8]`)
+are covered by the same tests and produce identical results across C++, TypeScript, and Python.
+
+## Intended downstream use
+
+The reported region is a *fetch plan*. A typical pipeline:
+
+1. Call `resample-bounding-box(transform, fixed, moving, padding=…)` with **metadata-only** fixed and moving images.
+2. Read `paddedStartIndex` and `paddedSize` and fetch only that sub-region of the moving image (a streamed read,
+   a chunk request, or an `itk::RegionOfInterestImageFilter`-style crop) — intersecting with the moving image's
+   largest possible region if you need to stay in bounds.
+3. Perform the real resample of the fixed grid through the same `transform`, now reading pixels only from the
+   fetched block. See [[downsample]] for the resampling/anti-aliasing side, and [[affine-ops]] for constructing
+   and composing the affine transforms fed in here.
+
+Because the region is computed from metadata alone, steps 1–2 are cheap enough to run before deciding whether a
+resample is even worthwhile (e.g. skipping non-overlapping tiles).
+
+## See also
+
+- [[downsample]] — the resampling / anti-aliasing pipelines in this package.
+- [[affine-ops]] — building, inverting, and composing the affine transforms consumed by this pipeline.
diff --git a/packages/downsample/package.json b/packages/downsample/package.json
index 77e47895c..3732998a2 100644
--- a/packages/downsample/package.json
+++ b/packages/downsample/package.json
@@ -14,7 +14,11 @@
     "typescript-package-name": "@itk-wasm/downsample",
     "python-package-name": "itkwasm-downsample",
     "package-description": "Pipelines for downsampling images.",
-    "repository": "https://github.com/InsightSoftwareConsortium/ITK-Wasm"
+    "repository": "https://github.com/InsightSoftwareConsortium/ITK-Wasm",
+    "bindgen-exclude": [
+      "resample-bounding-box-generate-inputs",
+      "resample-bounding-box-test"
+    ]
   },
   "scripts": {
     "build": "pnpm build:gen:typescript && pnpm build:gen:python",
@@ -41,6 +45,7 @@
     "@itk-wasm/dam": "^1.1.0",
     "itk-wasm": "workspace:^",
     "@itk-wasm/compare-images-build": "workspace:^",
-    "@itk-wasm/image-io-build": "workspace:^"
+    "@itk-wasm/image-io-build": "workspace:^",
+    "@itk-wasm/transform-io-build": "workspace:^"
   }
 }
diff --git a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/__init__.py b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/__init__.py
index e6997c61b..9ec5194bf 100644
--- a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/__init__.py
+++ b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/__init__.py
@@ -7,5 +7,6 @@
 from .downsample_sigma_async import downsample_sigma_async
 from .downsample_async import downsample_async
 from .gaussian_kernel_radius_async import gaussian_kernel_radius_async
+from .resample_bounding_box_async import resample_bounding_box_async
 
 from ._version import __version__
diff --git a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/gaussian_kernel_radius_async.py b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/gaussian_kernel_radius_async.py
index 6becb4838..1c73e11d0 100644
--- a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/gaussian_kernel_radius_async.py
+++ b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/gaussian_kernel_radius_async.py
@@ -46,9 +46,9 @@ async def gaussian_kernel_radius_async(
         kwargs["size"] = to_js(size)
     if sigma:
         kwargs["sigma"] = to_js(sigma)
-    if max_kernel_width:
+    if max_kernel_width is not None:
         kwargs["maxKernelWidth"] = to_js(max_kernel_width)
-    if max_kernel_error:
+    if max_kernel_error is not None:
         kwargs["maxKernelError"] = to_js(max_kernel_error)
 
     outputs = await js_module.gaussianKernelRadius(webWorker=web_worker, noCopy=True, **kwargs)
diff --git a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/js_package.py b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/js_package.py
index ff3532c3f..8663f3aff 100644
--- a/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/js_package.py
+++ b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/js_package.py
@@ -3,6 +3,6 @@
 from itkwasm.pyodide import JsPackageConfig, JsPackage
 
 from ._version import __version__
-default_js_module = """data:text/javascript;base64,var tI=Object.defineProperty;var II=(A,e)=>{for(var t in e)tI(A,t,{get:e[t],enumerable:!0})};var rI="1.8.1",ee=rI;var iI={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},N=iI;var gI={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},X=gI;function oI(A,e){let t=null;switch(A){case N.UInt8:{t=new Uint8Array(e);break}case N.Int8:{t=new Int8Array(e);break}case N.UInt16:{t=new Uint16Array(e);break}case N.Int16:{t=new Int16Array(e);break}case N.UInt32:{t=new Uint32Array(e);break}case N.Int32:{t=new Int32Array(e);break}case N.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case N.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case X.Float32:{t=new Float32Array(e);break}case X.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 O=oI;var nI={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",PointSet:"PointSet",Mesh:"Mesh",PolyData:"PolyData",TransformList:"TransformList",JsonCompatible:"JsonCompatible"},d=nI;var xe=Symbol("Comlink.proxy"),aI=Symbol("Comlink.endpoint"),re=Symbol("Comlink.releaseProxy"),te=Symbol("Comlink.finalizer"),NA=Symbol("Comlink.thrown"),We=A=>typeof A=="object"&&A!==null||typeof A=="function",sI={canHandle:A=>We(A)&&A[xe],serialize(A){let{port1:e,port2:t}=new MessageChannel;return ve(A,e),[t,[t]]},deserialize(A){return A.start(),ie(A)}},CI={canHandle:A=>We(A)&&NA 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}},je=new Map([["proxy",sI],["throw",CI]]);function BI(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function ve(A,e=globalThis,t=["*"]){e.addEventListener("message",function I(r){if(!r||!r.data)return;if(!BI(t,r.origin)){console.warn(`Invalid origin '${r.origin}' for comlink proxy`);return}let{id:i,type:g,path:a}=Object.assign({path:[]},r.data),E=(r.data.argumentList||[]).map(z),C;try{let o=a.slice(0,-1).reduce((c,B)=>c[B],A),s=a.reduce((c,B)=>c[B],A);switch(g){case"GET":C=s;break;case"SET":o[a.slice(-1)[0]]=z(r.data.value),C=!0;break;case"APPLY":C=s.apply(o,E);break;case"CONSTRUCT":{let c=new s(...E);C=fI(c)}break;case"ENDPOINT":{let{port1:c,port2:B}=new MessageChannel;ve(A,B),C=ge(c,[c])}break;case"RELEASE":C=void 0;break;default:return}}catch(o){C={value:o,[NA]:0}}Promise.resolve(C).catch(o=>({value:o,[NA]:0})).then(o=>{let[s,c]=LA(o);e.postMessage(Object.assign(Object.assign({},s),{id:i}),c),g==="RELEASE"&&(e.removeEventListener("message",I),Ze(e),te in A&&typeof A[te]=="function"&&A[te]())}).catch(o=>{let[s,c]=LA({value:new TypeError("Unserializable return value"),[NA]:0});e.postMessage(Object.assign(Object.assign({},s),{id:i}),c)})}),e.start&&e.start()}function QI(A){return A.constructor.name==="MessagePort"}function Ze(A){QI(A)&&A.close()}function ie(A,e){return Ie(A,[],e)}function kA(A){if(A)throw new Error("Proxy has been released and is not useable")}function _e(A){return eA(A,{type:"RELEASE"}).then(()=>{Ze(A)})}var GA=new WeakMap,bA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(GA.get(A)||0)-1;GA.set(A,e),e===0&&_e(A)});function EI(A,e){let t=(GA.get(e)||0)+1;GA.set(e,t),bA&&bA.register(A,e,A)}function lI(A){bA&&bA.unregister(A)}function Ie(A,e=[],t=function(){}){let I=!1,r=new Proxy(t,{get(i,g){if(kA(I),g===re)return()=>{lI(r),_e(A),I=!0};if(g==="then"){if(e.length===0)return{then:()=>r};let a=eA(A,{type:"GET",path:e.map(E=>E.toString())}).then(z);return a.then.bind(a)}return Ie(A,[...e,g])},set(i,g,a){kA(I);let[E,C]=LA(a);return eA(A,{type:"SET",path:[...e,g].map(o=>o.toString()),value:E},C).then(z)},apply(i,g,a){kA(I);let E=e[e.length-1];if(E===aI)return eA(A,{type:"ENDPOINT"}).then(z);if(E==="bind")return Ie(A,e.slice(0,-1));let[C,o]=Pe(a);return eA(A,{type:"APPLY",path:e.map(s=>s.toString()),argumentList:C},o).then(z)},construct(i,g){kA(I);let[a,E]=Pe(g);return eA(A,{type:"CONSTRUCT",path:e.map(C=>C.toString()),argumentList:a},E).then(z)}});return EI(r,A),r}function cI(A){return Array.prototype.concat.apply([],A)}function Pe(A){let e=A.map(LA);return[e.map(t=>t[0]),cI(e.map(t=>t[1]))]}var Ve=new WeakMap;function ge(A,e){return Ve.set(A,e),A}function fI(A){return Object.assign(A,{[xe]:!0})}function LA(A){for(let[e,t]of je)if(t.canHandle(A)){let[I,r]=t.serialize(A);return[{type:"HANDLER",name:e,value:I},r]}return[{type:"RAW",value:A},Ve.get(A)||[]]}function z(A){switch(A.type){case"HANDLER":return je.get(A.name).deserialize(A.value);case"RAW":return A.value}}function eA(A,e,t){return new Promise(I=>{let r=uI();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 uI(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function BA(A,e){return function(){return A.apply(e,arguments)}}var{toString:dI}=Object.prototype,{getPrototypeOf:ne}=Object,{iterator:HA,toStringTag:$e}=Symbol,MA=(A=>e=>{let t=dI.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),M=A=>(A=A.toLowerCase(),e=>MA(e)===A),YA=A=>e=>typeof e===A,{isArray:IA}=Array,tA=YA("undefined");function QA(A){return A!==null&&!tA(A)&&A.constructor!==null&&!tA(A.constructor)&&G(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var At=M("ArrayBuffer");function pI(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&At(A.buffer),e}var hI=YA("string"),G=YA("function"),et=YA("number"),EA=A=>A!==null&&typeof A=="object",DI=A=>A===!0||A===!1,JA=A=>{if(MA(A)!=="object")return!1;let e=ne(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!($e in A)&&!(HA in A)},yI=A=>{if(!EA(A)||QA(A))return!1;try{return Object.keys(A).length===0&&Object.getPrototypeOf(A)===Object.prototype}catch{return!1}},wI=M("Date"),mI=M("File"),SI=M("Blob"),RI=M("FileList"),FI=A=>EA(A)&&G(A.pipe),UI=A=>{let e;return A&&(typeof FormData=="function"&&A instanceof FormData||G(A.append)&&((e=MA(A))==="formdata"||e==="object"&&G(A.toString)&&A.toString()==="[object FormData]"))},kI=M("URLSearchParams"),[NI,GI,bI,LI]=["ReadableStream","Request","Response","Headers"].map(M),JI=A=>A.trim?A.trim():A.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function lA(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let I,r;if(typeof A!="object"&&(A=[A]),IA(A))for(I=0,r=A.length;I<r;I++)e.call(null,A[I],I,A);else{if(QA(A))return;let i=t?Object.getOwnPropertyNames(A):Object.keys(A),g=i.length,a;for(I=0;I<g;I++)a=i[I],e.call(null,A[a],a,A)}}function tt(A,e){if(QA(A))return null;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 $=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,It=A=>!tA(A)&&A!==$;function oe(){let{caseless:A,skipUndefined:e}=It(this)&&this||{},t={},I=(r,i)=>{if(i==="__proto__"||i==="constructor"||i==="prototype")return;let g=A&&tt(t,i)||i;JA(t[g])&&JA(r)?t[g]=oe(t[g],r):JA(r)?t[g]=oe({},r):IA(r)?t[g]=r.slice():(!e||!tA(r))&&(t[g]=r)};for(let r=0,i=arguments.length;r<i;r++)arguments[r]&&lA(arguments[r],I);return t}var HI=(A,e,t,{allOwnKeys:I}={})=>(lA(e,(r,i)=>{t&&G(r)?Object.defineProperty(A,i,{value:BA(r,t),writable:!0,enumerable:!0,configurable:!0}):Object.defineProperty(A,i,{value:r,writable:!0,enumerable:!0,configurable:!0})},{allOwnKeys:I}),A),MI=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),YI=(A,e,t,I)=>{A.prototype=Object.create(e.prototype,I),Object.defineProperty(A.prototype,"constructor",{value:A,writable:!0,enumerable:!1,configurable:!0}),Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},qI=(A,e,t,I)=>{let r,i,g,a={};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))&&!a[g]&&(e[g]=A[g],a[g]=!0);A=t!==!1&&ne(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},OI=(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},KI=A=>{if(!A)return null;if(IA(A))return A;let e=A.length;if(!et(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},TI=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&ne(Uint8Array)),PI=(A,e)=>{let I=(A&&A[HA]).call(A),r;for(;(r=I.next())&&!r.done;){let i=r.value;e.call(A,i[0],i[1])}},xI=(A,e)=>{let t,I=[];for(;(t=A.exec(e))!==null;)I.push(t);return I},WI=M("HTMLFormElement"),jI=A=>A.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(t,I,r){return I.toUpperCase()+r}),ze=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),vI=M("RegExp"),rt=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),I={};lA(t,(r,i)=>{let g;(g=e(r,i,A))!==!1&&(I[i]=g||r)}),Object.defineProperties(A,I)},ZI=A=>{rt(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+"'")})}})},_I=(A,e)=>{let t={},I=r=>{r.forEach(i=>{t[i]=!0})};return IA(A)?I(A):I(String(A).split(e)),t},VI=()=>{},XI=(A,e)=>A!=null&&Number.isFinite(A=+A)?A:e;function zI(A){return!!(A&&G(A.append)&&A[$e]==="FormData"&&A[HA])}var $I=A=>{let e=new Array(10),t=(I,r)=>{if(EA(I)){if(e.indexOf(I)>=0)return;if(QA(I))return I;if(!("toJSON"in I)){e[r]=I;let i=IA(I)?[]:{};return lA(I,(g,a)=>{let E=t(g,r+1);!tA(E)&&(i[a]=E)}),e[r]=void 0,i}}return I};return t(A,0)},Ar=M("AsyncFunction"),er=A=>A&&(EA(A)||G(A))&&G(A.then)&&G(A.catch),it=((A,e)=>A?setImmediate:e?((t,I)=>($.addEventListener("message",({source:r,data:i})=>{r===$&&i===t&&I.length&&I.shift()()},!1),r=>{I.push(r),$.postMessage(t,"*")}))(`axios@${Math.random()}`,[]):t=>setTimeout(t))(typeof setImmediate=="function",G($.postMessage)),tr=typeof queueMicrotask<"u"?queueMicrotask.bind($):typeof process<"u"&&process.nextTick||it,Ir=A=>A!=null&&G(A[HA]),n={isArray:IA,isArrayBuffer:At,isBuffer:QA,isFormData:UI,isArrayBufferView:pI,isString:hI,isNumber:et,isBoolean:DI,isObject:EA,isPlainObject:JA,isEmptyObject:yI,isReadableStream:NI,isRequest:GI,isResponse:bI,isHeaders:LI,isUndefined:tA,isDate:wI,isFile:mI,isBlob:SI,isRegExp:vI,isFunction:G,isStream:FI,isURLSearchParams:kI,isTypedArray:TI,isFileList:RI,forEach:lA,merge:oe,extend:HI,trim:JI,stripBOM:MI,inherits:YI,toFlatObject:qI,kindOf:MA,kindOfTest:M,endsWith:OI,toArray:KI,forEachEntry:PI,matchAll:xI,isHTMLForm:WI,hasOwnProperty:ze,hasOwnProp:ze,reduceDescriptors:rt,freezeMethods:ZI,toObjectSet:_I,toCamelCase:jI,noop:VI,toFiniteNumber:XI,findKey:tt,global:$,isContextDefined:It,isSpecCompliantForm:zI,toJSONObject:$I,isAsyncFn:Ar,isThenable:er,setImmediate:it,asap:tr,isIterable:Ir};var F=class A extends Error{static from(e,t,I,r,i,g){let a=new A(e.message,t||e.code,I,r,i);return a.cause=e,a.name=e.name,g&&Object.assign(a,g),a}constructor(e,t,I,r,i){super(e),this.name="AxiosError",this.isAxiosError=!0,t&&(this.code=t),I&&(this.config=I),r&&(this.request=r),i&&(this.response=i,this.status=i.status)}toJSON(){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:n.toJSONObject(this.config),code:this.code,status:this.status}}};F.ERR_BAD_OPTION_VALUE="ERR_BAD_OPTION_VALUE";F.ERR_BAD_OPTION="ERR_BAD_OPTION";F.ECONNABORTED="ECONNABORTED";F.ETIMEDOUT="ETIMEDOUT";F.ERR_NETWORK="ERR_NETWORK";F.ERR_FR_TOO_MANY_REDIRECTS="ERR_FR_TOO_MANY_REDIRECTS";F.ERR_DEPRECATED="ERR_DEPRECATED";F.ERR_BAD_RESPONSE="ERR_BAD_RESPONSE";F.ERR_BAD_REQUEST="ERR_BAD_REQUEST";F.ERR_CANCELED="ERR_CANCELED";F.ERR_NOT_SUPPORT="ERR_NOT_SUPPORT";F.ERR_INVALID_URL="ERR_INVALID_URL";var u=F;var qA=null;function ae(A){return n.isPlainObject(A)||n.isArray(A)}function ot(A){return n.endsWith(A,"[]")?A.slice(0,-2):A}function gt(A,e,t){return A?A.concat(e).map(function(r,i){return r=ot(r),!t&&i?"["+r+"]":r}).join(t?".":""):e}function rr(A){return n.isArray(A)&&!A.some(ae)}var ir=n.toFlatObject(n,{},null,function(e){return/^is[A-Z]/.test(e)});function gr(A,e,t){if(!n.isObject(A))throw new TypeError("target must be an object");e=e||new(qA||FormData),t=n.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(f,l){return!n.isUndefined(l[f])});let I=t.metaTokens,r=t.visitor||o,i=t.dots,g=t.indexes,E=(t.Blob||typeof Blob<"u"&&Blob)&&n.isSpecCompliantForm(e);if(!n.isFunction(r))throw new TypeError("visitor must be a function");function C(Q){if(Q===null)return"";if(n.isDate(Q))return Q.toISOString();if(n.isBoolean(Q))return Q.toString();if(!E&&n.isBlob(Q))throw new u("Blob is not supported. Use a Buffer instead.");return n.isArrayBuffer(Q)||n.isTypedArray(Q)?E&&typeof Blob=="function"?new Blob([Q]):Buffer.from(Q):Q}function o(Q,f,l){let p=Q;if(Q&&!l&&typeof Q=="object"){if(n.endsWith(f,"{}"))f=I?f:f.slice(0,-2),Q=JSON.stringify(Q);else if(n.isArray(Q)&&rr(Q)||(n.isFileList(Q)||n.endsWith(f,"[]"))&&(p=n.toArray(Q)))return f=ot(f),p.forEach(function(D,U){!(n.isUndefined(D)||D===null)&&e.append(g===!0?gt([f],U,i):g===null?f:f+"[]",C(D))}),!1}return ae(Q)?!0:(e.append(gt(l,f,i),C(Q)),!1)}let s=[],c=Object.assign(ir,{defaultVisitor:o,convertValue:C,isVisitable:ae});function B(Q,f){if(!n.isUndefined(Q)){if(s.indexOf(Q)!==-1)throw Error("Circular reference detected in "+f.join("."));s.push(Q),n.forEach(Q,function(p,R){(!(n.isUndefined(p)||p===null)&&r.call(e,p,n.isString(R)?R.trim():R,f,c))===!0&&B(p,f?f.concat(R):[R])}),s.pop()}}if(!n.isObject(A))throw new TypeError("data must be an object");return B(A),e}var v=gr;function nt(A){let e={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+","%00":"\0"};return encodeURIComponent(A).replace(/[!'()~]|%20|%00/g,function(I){return e[I]})}function at(A,e){this._pairs=[],A&&v(A,this,e)}var st=at.prototype;st.append=function(e,t){this._pairs.push([e,t])};st.toString=function(e){let t=e?function(I){return e.call(this,I,nt)}:nt;return this._pairs.map(function(r){return t(r[0])+"="+t(r[1])},"").join("&")};var OA=at;function or(A){return encodeURIComponent(A).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+")}function cA(A,e,t){if(!e)return A;let I=t&&t.encode||or,r=n.isFunction(t)?{serialize:t}:t,i=r&&r.serialize,g;if(i?g=i(e,r):g=n.isURLSearchParams(e)?e.toString():new OA(e,r).toString(I),g){let a=A.indexOf("#");a!==-1&&(A=A.slice(0,a)),A+=(A.indexOf("?")===-1?"?":"&")+g}return A}var se=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){n.forEach(this.handlers,function(I){I!==null&&e(I)})}},Ce=se;var rA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1,legacyInterceptorReqResOrdering:!0};var Ct=typeof URLSearchParams<"u"?URLSearchParams:OA;var Bt=typeof FormData<"u"?FormData:null;var Qt=typeof Blob<"u"?Blob:null;var Et={isBrowser:!0,classes:{URLSearchParams:Ct,FormData:Bt,Blob:Qt},protocols:["http","https","file","blob","url","data"]};var Ee={};II(Ee,{hasBrowserEnv:()=>Qe,hasStandardBrowserEnv:()=>nr,hasStandardBrowserWebWorkerEnv:()=>ar,navigator:()=>Be,origin:()=>sr});var Qe=typeof window<"u"&&typeof document<"u",Be=typeof navigator=="object"&&navigator||void 0,nr=Qe&&(!Be||["ReactNative","NativeScript","NS"].indexOf(Be.product)<0),ar=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function",sr=Qe&&window.location.href||"http://localhost";var h={...Ee,...Et};function le(A,e){return v(A,new h.classes.URLSearchParams,{visitor:function(t,I,r,i){return h.isNode&&n.isBuffer(t)?(this.append(I,t.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)},...e})}function Cr(A){return n.matchAll(/\w+|\[(\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function Br(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 Qr(A){function e(t,I,r,i){let g=t[i++];if(g==="__proto__")return!0;let a=Number.isFinite(+g),E=i>=t.length;return g=!g&&n.isArray(r)?r.length:g,E?(n.hasOwnProp(r,g)?r[g]=[r[g],I]:r[g]=I,!a):((!r[g]||!n.isObject(r[g]))&&(r[g]=[]),e(t,I,r[g],i)&&n.isArray(r[g])&&(r[g]=Br(r[g])),!a)}if(n.isFormData(A)&&n.isFunction(A.entries)){let t={};return n.forEachEntry(A,(I,r)=>{e(Cr(I),r,t,0)}),t}return null}var KA=Qr;function Er(A,e,t){if(n.isString(A))try{return(e||JSON.parse)(A),n.trim(A)}catch(I){if(I.name!=="SyntaxError")throw I}return(t||JSON.stringify)(A)}var ce={transitional:rA,adapter:["xhr","http","fetch"],transformRequest:[function(e,t){let I=t.getContentType()||"",r=I.indexOf("application/json")>-1,i=n.isObject(e);if(i&&n.isHTMLForm(e)&&(e=new FormData(e)),n.isFormData(e))return r?JSON.stringify(KA(e)):e;if(n.isArrayBuffer(e)||n.isBuffer(e)||n.isStream(e)||n.isFile(e)||n.isBlob(e)||n.isReadableStream(e))return e;if(n.isArrayBufferView(e))return e.buffer;if(n.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let a;if(i){if(I.indexOf("application/x-www-form-urlencoded")>-1)return le(e,this.formSerializer).toString();if((a=n.isFileList(e))||I.indexOf("multipart/form-data")>-1){let E=this.env&&this.env.FormData;return v(a?{"files[]":e}:e,E&&new E,this.formSerializer)}}return i||r?(t.setContentType("application/json",!1),Er(e)):e}],transformResponse:[function(e){let t=this.transitional||ce.transitional,I=t&&t.forcedJSONParsing,r=this.responseType==="json";if(n.isResponse(e)||n.isReadableStream(e))return e;if(e&&n.isString(e)&&(I&&!this.responseType||r)){let g=!(t&&t.silentJSONParsing)&&r;try{return JSON.parse(e,this.parseReviver)}catch(a){if(g)throw a.name==="SyntaxError"?u.from(a,u.ERR_BAD_RESPONSE,this,null,this.response):a}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:h.classes.FormData,Blob:h.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};n.forEach(["delete","get","head","post","put","patch"],A=>{ce.headers[A]={}});var iA=ce;var lr=n.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"]),lt=A=>{let e={},t,I,r;return A&&A.split(`
`).forEach(function(g){r=g.indexOf(":"),t=g.substring(0,r).trim().toLowerCase(),I=g.substring(r+1).trim(),!(!t||e[t]&&lr[t])&&(t==="set-cookie"?e[t]?e[t].push(I):e[t]=[I]:e[t]=e[t]?e[t]+", "+I:I)}),e};var ct=Symbol("internals");function fA(A){return A&&String(A).trim().toLowerCase()}function TA(A){return A===!1||A==null?A:n.isArray(A)?A.map(TA):String(A)}function cr(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 fr=A=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(A.trim());function fe(A,e,t,I,r){if(n.isFunction(I))return I.call(this,e,t);if(r&&(e=t),!!n.isString(e)){if(n.isString(I))return e.indexOf(I)!==-1;if(n.isRegExp(I))return I.test(e)}}function ur(A){return A.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(e,t,I)=>t.toUpperCase()+I)}function dr(A,e){let t=n.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 gA=class{constructor(e){e&&this.set(e)}set(e,t,I){let r=this;function i(a,E,C){let o=fA(E);if(!o)throw new Error("header name must be a non-empty string");let s=n.findKey(r,o);(!s||r[s]===void 0||C===!0||C===void 0&&r[s]!==!1)&&(r[s||E]=TA(a))}let g=(a,E)=>n.forEach(a,(C,o)=>i(C,o,E));if(n.isPlainObject(e)||e instanceof this.constructor)g(e,t);else if(n.isString(e)&&(e=e.trim())&&!fr(e))g(lt(e),t);else if(n.isObject(e)&&n.isIterable(e)){let a={},E,C;for(let o of e){if(!n.isArray(o))throw TypeError("Object iterator must return a key-value pair");a[C=o[0]]=(E=a[C])?n.isArray(E)?[...E,o[1]]:[E,o[1]]:o[1]}g(a,t)}else e!=null&&i(t,e,I);return this}get(e,t){if(e=fA(e),e){let I=n.findKey(this,e);if(I){let r=this[I];if(!t)return r;if(t===!0)return cr(r);if(n.isFunction(t))return t.call(this,r,I);if(n.isRegExp(t))return t.exec(r);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=fA(e),e){let I=n.findKey(this,e);return!!(I&&this[I]!==void 0&&(!t||fe(this,this[I],I,t)))}return!1}delete(e,t){let I=this,r=!1;function i(g){if(g=fA(g),g){let a=n.findKey(I,g);a&&(!t||fe(I,I[a],a,t))&&(delete I[a],r=!0)}}return n.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||fe(this,this[i],i,e,!0))&&(delete this[i],r=!0)}return r}normalize(e){let t=this,I={};return n.forEach(this,(r,i)=>{let g=n.findKey(I,i);if(g){t[g]=TA(r),delete t[i];return}let a=e?ur(i):String(i).trim();a!==i&&delete t[i],t[a]=TA(r),I[a]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return n.forEach(this,(I,r)=>{I!=null&&I!==!1&&(t[r]=e&&n.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(`
`)}getSetCookie(){return this.get("set-cookie")||[]}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[ct]=this[ct]={accessors:{}}).accessors,r=this.prototype;function i(g){let a=fA(g);I[a]||(dr(r,g),I[a]=!0)}return n.isArray(e)?e.forEach(i):i(e),this}};gA.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);n.reduceDescriptors(gA.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(I){this[t]=I}}});n.freezeMethods(gA);var m=gA;function uA(A,e){let t=this||iA,I=e||t,r=m.from(I.headers),i=I.data;return n.forEach(A,function(a){i=a.call(t,i,r.normalize(),e?e.status:void 0)}),r.normalize(),i}function dA(A){return!!(A&&A.__CANCEL__)}var ue=class extends u{constructor(e,t,I){super(e??"canceled",u.ERR_CANCELED,t,I),this.name="CanceledError",this.__CANCEL__=!0}},K=ue;function pA(A,e,t){let I=t.config.validateStatus;!t.status||!I||I(t.status)?A(t):e(new u("Request failed with status code "+t.status,[u.ERR_BAD_REQUEST,u.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}function de(A){let e=/^([-+\w]{1,25})(:?\/\/|:)/.exec(A);return e&&e[1]||""}function pr(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 s=i,c=0;for(;s!==r;)c+=t[s++],s=s%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(c*1e3/B):void 0}}var ft=pr;function hr(A,e){let t=0,I=1e3/e,r,i,g=(C,o=Date.now())=>{t=o,r=null,i&&(clearTimeout(i),i=null),A(...C)};return[(...C)=>{let o=Date.now(),s=o-t;s>=I?g(C,o):(r=C,i||(i=setTimeout(()=>{i=null,g(r)},I-s)))},()=>r&&g(r)]}var ut=hr;var oA=(A,e,t=3)=>{let I=0,r=ft(50,250);return ut(i=>{let g=i.loaded,a=i.lengthComputable?i.total:void 0,E=g-I,C=r(E),o=g<=a;I=g;let s={loaded:g,total:a,progress:a?g/a:void 0,bytes:E,rate:C||void 0,estimated:C&&a&&o?(a-g)/C:void 0,event:i,lengthComputable:a!=null,[e?"download":"upload"]:!0};A(s)},t)},pe=(A,e)=>{let t=A!=null;return[I=>e[0]({lengthComputable:t,total:A,loaded:I}),e[1]]},he=A=>(...e)=>n.asap(()=>A(...e));var dt=h.hasStandardBrowserEnv?((A,e)=>t=>(t=new URL(t,h.origin),A.protocol===t.protocol&&A.host===t.host&&(e||A.port===t.port)))(new URL(h.origin),h.navigator&&/(msie|trident)/i.test(h.navigator.userAgent)):()=>!0;var pt=h.hasStandardBrowserEnv?{write(A,e,t,I,r,i,g){if(typeof document>"u")return;let a=[`${A}=${encodeURIComponent(e)}`];n.isNumber(t)&&a.push(`expires=${new Date(t).toUTCString()}`),n.isString(I)&&a.push(`path=${I}`),n.isString(r)&&a.push(`domain=${r}`),i===!0&&a.push("secure"),n.isString(g)&&a.push(`SameSite=${g}`),document.cookie=a.join("; ")},read(A){if(typeof document>"u")return null;let e=document.cookie.match(new RegExp("(?:^|; )"+A+"=([^;]*)"));return e?decodeURIComponent(e[1]):null},remove(A){this.write(A,"",Date.now()-864e5,"/")}}:{write(){},read(){return null},remove(){}};function De(A){return typeof A!="string"?!1:/^([a-z][a-z\d+\-.]*:)?\/\//i.test(A)}function ye(A,e){return e?A.replace(/\/?\/$/,"")+"/"+e.replace(/^\/+/,""):A}function hA(A,e,t){let I=!De(e);return A&&(I||t==!1)?ye(A,e):e}var ht=A=>A instanceof m?{...A}:A;function Y(A,e){e=e||{};let t={};function I(C,o,s,c){return n.isPlainObject(C)&&n.isPlainObject(o)?n.merge.call({caseless:c},C,o):n.isPlainObject(o)?n.merge({},o):n.isArray(o)?o.slice():o}function r(C,o,s,c){if(n.isUndefined(o)){if(!n.isUndefined(C))return I(void 0,C,s,c)}else return I(C,o,s,c)}function i(C,o){if(!n.isUndefined(o))return I(void 0,o)}function g(C,o){if(n.isUndefined(o)){if(!n.isUndefined(C))return I(void 0,C)}else return I(void 0,o)}function a(C,o,s){if(s in e)return I(C,o);if(s 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,withXSRFToken: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:a,headers:(C,o,s)=>r(ht(C),ht(o),s,!0)};return n.forEach(Object.keys({...A,...e}),function(o){if(o==="__proto__"||o==="constructor"||o==="prototype")return;let s=n.hasOwnProp(E,o)?E[o]:r,c=s(A[o],e[o],o);n.isUndefined(c)&&s!==a||(t[o]=c)}),t}var PA=A=>{let e=Y({},A),{data:t,withXSRFToken:I,xsrfHeaderName:r,xsrfCookieName:i,headers:g,auth:a}=e;if(e.headers=g=m.from(g),e.url=cA(hA(e.baseURL,e.url,e.allowAbsoluteUrls),A.params,A.paramsSerializer),a&&g.set("Authorization","Basic "+btoa((a.username||"")+":"+(a.password?unescape(encodeURIComponent(a.password)):""))),n.isFormData(t)){if(h.hasStandardBrowserEnv||h.hasStandardBrowserWebWorkerEnv)g.setContentType(void 0);else if(n.isFunction(t.getHeaders)){let E=t.getHeaders(),C=["content-type","content-length"];Object.entries(E).forEach(([o,s])=>{C.includes(o.toLowerCase())&&g.set(o,s)})}}if(h.hasStandardBrowserEnv&&(I&&n.isFunction(I)&&(I=I(e)),I||I!==!1&&dt(e.url))){let E=r&&i&&pt.read(i);E&&g.set(r,E)}return e};var Dr=typeof XMLHttpRequest<"u",Dt=Dr&&function(A){return new Promise(function(t,I){let r=PA(A),i=r.data,g=m.from(r.headers).normalize(),{responseType:a,onUploadProgress:E,onDownloadProgress:C}=r,o,s,c,B,Q;function f(){B&&B(),Q&&Q(),r.cancelToken&&r.cancelToken.unsubscribe(o),r.signal&&r.signal.removeEventListener("abort",o)}let l=new XMLHttpRequest;l.open(r.method.toUpperCase(),r.url,!0),l.timeout=r.timeout;function p(){if(!l)return;let D=m.from("getAllResponseHeaders"in l&&l.getAllResponseHeaders()),H={data:!a||a==="text"||a==="json"?l.responseText:l.response,status:l.status,statusText:l.statusText,headers:D,config:A,request:l};pA(function(b){t(b),f()},function(b){I(b),f()},H),l=null}"onloadend"in l?l.onloadend=p:l.onreadystatechange=function(){!l||l.readyState!==4||l.status===0&&!(l.responseURL&&l.responseURL.indexOf("file:")===0)||setTimeout(p)},l.onabort=function(){l&&(I(new u("Request aborted",u.ECONNABORTED,A,l)),l=null)},l.onerror=function(U){let H=U&&U.message?U.message:"Network Error",_=new u(H,u.ERR_NETWORK,A,l);_.event=U||null,I(_),l=null},l.ontimeout=function(){let U=r.timeout?"timeout of "+r.timeout+"ms exceeded":"timeout exceeded",H=r.transitional||rA;r.timeoutErrorMessage&&(U=r.timeoutErrorMessage),I(new u(U,H.clarifyTimeoutError?u.ETIMEDOUT:u.ECONNABORTED,A,l)),l=null},i===void 0&&g.setContentType(null),"setRequestHeader"in l&&n.forEach(g.toJSON(),function(U,H){l.setRequestHeader(H,U)}),n.isUndefined(r.withCredentials)||(l.withCredentials=!!r.withCredentials),a&&a!=="json"&&(l.responseType=r.responseType),C&&([c,Q]=oA(C,!0),l.addEventListener("progress",c)),E&&l.upload&&([s,B]=oA(E),l.upload.addEventListener("progress",s),l.upload.addEventListener("loadend",B)),(r.cancelToken||r.signal)&&(o=D=>{l&&(I(!D||D.type?new K(null,A,l):D),l.abort(),l=null)},r.cancelToken&&r.cancelToken.subscribe(o),r.signal&&(r.signal.aborted?o():r.signal.addEventListener("abort",o)));let R=de(r.url);if(R&&h.protocols.indexOf(R)===-1){I(new u("Unsupported protocol "+R+":",u.ERR_BAD_REQUEST,A));return}l.send(i||null)})};var yr=(A,e)=>{let{length:t}=A=A?A.filter(Boolean):[];if(e||t){let I=new AbortController,r,i=function(C){if(!r){r=!0,a();let o=C instanceof Error?C:this.reason;I.abort(o instanceof u?o:new K(o instanceof Error?o.message:o))}},g=e&&setTimeout(()=>{g=null,i(new u(`timeout of ${e}ms exceeded`,u.ETIMEDOUT))},e),a=()=>{A&&(g&&clearTimeout(g),g=null,A.forEach(C=>{C.unsubscribe?C.unsubscribe(i):C.removeEventListener("abort",i)}),A=null)};A.forEach(C=>C.addEventListener("abort",i));let{signal:E}=I;return E.unsubscribe=()=>n.asap(a),E}},yt=yr;var wr=function*(A,e){let t=A.byteLength;if(!e||t<e){yield A;return}let I=0,r;for(;I<t;)r=I+e,yield A.slice(I,r),I=r},mr=async function*(A,e){for await(let t of Sr(A))yield*wr(t,e)},Sr=async function*(A){if(A[Symbol.asyncIterator]){yield*A;return}let e=A.getReader();try{for(;;){let{done:t,value:I}=await e.read();if(t)break;yield I}}finally{await e.cancel()}},we=(A,e,t,I)=>{let r=mr(A,e),i=0,g,a=E=>{g||(g=!0,I&&I(E))};return new ReadableStream({async pull(E){try{let{done:C,value:o}=await r.next();if(C){a(),E.close();return}let s=o.byteLength;if(t){let c=i+=s;t(c)}E.enqueue(new Uint8Array(o))}catch(C){throw a(C),C}},cancel(E){return a(E),r.return()}},{highWaterMark:2})};var wt=64*1024,{isFunction:xA}=n,Rr=(({Request:A,Response:e})=>({Request:A,Response:e}))(n.global),{ReadableStream:mt,TextEncoder:St}=n.global,Rt=(A,...e)=>{try{return!!A(...e)}catch{return!1}},Fr=A=>{A=n.merge.call({skipUndefined:!0},Rr,A);let{fetch:e,Request:t,Response:I}=A,r=e?xA(e):typeof fetch=="function",i=xA(t),g=xA(I);if(!r)return!1;let a=r&&xA(mt),E=r&&(typeof St=="function"?(Q=>f=>Q.encode(f))(new St):async Q=>new Uint8Array(await new t(Q).arrayBuffer())),C=i&&a&&Rt(()=>{let Q=!1,f=new t(h.origin,{body:new mt,method:"POST",get duplex(){return Q=!0,"half"}}).headers.has("Content-Type");return Q&&!f}),o=g&&a&&Rt(()=>n.isReadableStream(new I("").body)),s={stream:o&&(Q=>Q.body)};r&&["text","arrayBuffer","blob","formData","stream"].forEach(Q=>{!s[Q]&&(s[Q]=(f,l)=>{let p=f&&f[Q];if(p)return p.call(f);throw new u(`Response type '${Q}' is not supported`,u.ERR_NOT_SUPPORT,l)})});let c=async Q=>{if(Q==null)return 0;if(n.isBlob(Q))return Q.size;if(n.isSpecCompliantForm(Q))return(await new t(h.origin,{method:"POST",body:Q}).arrayBuffer()).byteLength;if(n.isArrayBufferView(Q)||n.isArrayBuffer(Q))return Q.byteLength;if(n.isURLSearchParams(Q)&&(Q=Q+""),n.isString(Q))return(await E(Q)).byteLength},B=async(Q,f)=>{let l=n.toFiniteNumber(Q.getContentLength());return l??c(f)};return async Q=>{let{url:f,method:l,data:p,signal:R,cancelToken:D,timeout:U,onDownloadProgress:H,onUploadProgress:_,responseType:b,headers:$A,withCredentials:RA="same-origin",fetchOptions:Me}=PA(Q),Ye=e||fetch;b=b?(b+"").toLowerCase():"text";let FA=yt([R,D&&D.toAbortSignal()],U),CA=null,V=FA&&FA.unsubscribe&&(()=>{FA.unsubscribe()}),qe;try{if(_&&C&&l!=="get"&&l!=="head"&&(qe=await B($A,p))!==0){let j=new t(f,{method:"POST",body:p,duplex:"half"}),AA;if(n.isFormData(p)&&(AA=j.headers.get("content-type"))&&$A.setContentType(AA),j.body){let[Ae,UA]=pe(qe,oA(he(_)));p=we(j.body,wt,Ae,UA)}}n.isString(RA)||(RA=RA?"include":"omit");let k=i&&"credentials"in t.prototype,Oe={...Me,signal:FA,method:l.toUpperCase(),headers:$A.normalize().toJSON(),body:p,duplex:"half",credentials:k?RA:void 0};CA=i&&new t(f,Oe);let W=await(i?Ye(CA,Me):Ye(f,Oe)),Ke=o&&(b==="stream"||b==="response");if(o&&(H||Ke&&V)){let j={};["status","statusText","headers"].forEach(Te=>{j[Te]=W[Te]});let AA=n.toFiniteNumber(W.headers.get("content-length")),[Ae,UA]=H&&pe(AA,oA(he(H),!0))||[];W=new I(we(W.body,wt,Ae,()=>{UA&&UA(),V&&V()}),j)}b=b||"text";let eI=await s[n.findKey(s,b)||"text"](W,Q);return!Ke&&V&&V(),await new Promise((j,AA)=>{pA(j,AA,{data:eI,headers:m.from(W.headers),status:W.status,statusText:W.statusText,config:Q,request:CA})})}catch(k){throw V&&V(),k&&k.name==="TypeError"&&/Load failed|fetch/i.test(k.message)?Object.assign(new u("Network Error",u.ERR_NETWORK,Q,CA,k&&k.response),{cause:k.cause||k}):u.from(k,k&&k.code,Q,CA,k&&k.response)}}},Ur=new Map,me=A=>{let e=A&&A.env||{},{fetch:t,Request:I,Response:r}=e,i=[I,r,t],g=i.length,a=g,E,C,o=Ur;for(;a--;)E=i[a],C=o.get(E),C===void 0&&o.set(E,C=a?new Map:Fr(e)),o=C;return C},So=me();var Se={http:qA,xhr:Dt,fetch:{get:me}};n.forEach(Se,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var Ft=A=>`- ${A}`,Nr=A=>n.isFunction(A)||A===null||A===!1;function Gr(A,e){A=n.isArray(A)?A:[A];let{length:t}=A,I,r,i={};for(let g=0;g<t;g++){I=A[g];let a;if(r=I,!Nr(I)&&(r=Se[(a=String(I)).toLowerCase()],r===void 0))throw new u(`Unknown adapter '${a}'`);if(r&&(n.isFunction(r)||(r=r.get(e))))break;i[a||"#"+g]=r}if(!r){let g=Object.entries(i).map(([E,C])=>`adapter ${E} `+(C===!1?"is not supported by the environment":"is not available in the build")),a=t?g.length>1?`since :
`+g.map(Ft).join(`
`):" "+Ft(g[0]):"as no adapter specified";throw new u("There is no suitable adapter to dispatch the request "+a,"ERR_NOT_SUPPORT")}return r}var WA={getAdapter:Gr,adapters:Se};function Re(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new K(null,A)}function jA(A){return Re(A),A.headers=m.from(A.headers),A.data=uA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),WA.getAdapter(A.adapter||iA.adapter,A)(A).then(function(I){return Re(A),I.data=uA.call(A,A.transformResponse,I),I.headers=m.from(I.headers),I},function(I){return dA(I)||(Re(A),I&&I.response&&(I.response.data=uA.call(A,A.transformResponse,I.response),I.response.headers=m.from(I.response.headers))),Promise.reject(I)})}var vA="1.13.5";var ZA={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{ZA[A]=function(I){return typeof I===A||"a"+(e<1?"n ":" ")+A}});var Ut={};ZA.transitional=function(e,t,I){function r(i,g){return"[Axios v"+vA+"] Transitional option '"+i+"'"+g+(I?". "+I:"")}return(i,g,a)=>{if(e===!1)throw new u(r(g," has been removed"+(t?" in "+t:"")),u.ERR_DEPRECATED);return t&&!Ut[g]&&(Ut[g]=!0,console.warn(r(g," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(i,g,a):!0}};ZA.spelling=function(e){return(t,I)=>(console.warn(`${I} is likely a misspelling of ${e}`),!0)};function br(A,e,t){if(typeof A!="object")throw new u("options must be an object",u.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 a=A[i],E=a===void 0||g(a,i,A);if(E!==!0)throw new u("option "+i+" must be "+E,u.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new u("Unknown option "+i,u.ERR_BAD_OPTION)}}var DA={assertOptions:br,validators:ZA};var L=DA.validators,nA=class{constructor(e){this.defaults=e||{},this.interceptors={request:new Ce,response:new Ce}}async request(e,t){try{return await this._request(e,t)}catch(I){if(I instanceof Error){let r={};Error.captureStackTrace?Error.captureStackTrace(r):r=new Error;let i=r.stack?r.stack.replace(/^.+\n/,""):"";try{I.stack?i&&!String(I.stack).endsWith(i.replace(/^.+\n.+\n/,""))&&(I.stack+=`
`+i):I.stack=i}catch{}}throw I}}_request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=Y(this.defaults,t);let{transitional:I,paramsSerializer:r,headers:i}=t;I!==void 0&&DA.assertOptions(I,{silentJSONParsing:L.transitional(L.boolean),forcedJSONParsing:L.transitional(L.boolean),clarifyTimeoutError:L.transitional(L.boolean),legacyInterceptorReqResOrdering:L.transitional(L.boolean)},!1),r!=null&&(n.isFunction(r)?t.paramsSerializer={serialize:r}:DA.assertOptions(r,{encode:L.function,serialize:L.function},!0)),t.allowAbsoluteUrls!==void 0||(this.defaults.allowAbsoluteUrls!==void 0?t.allowAbsoluteUrls=this.defaults.allowAbsoluteUrls:t.allowAbsoluteUrls=!0),DA.assertOptions(t,{baseUrl:L.spelling("baseURL"),withXsrfToken:L.spelling("withXSRFToken")},!0),t.method=(t.method||this.defaults.method||"get").toLowerCase();let g=i&&n.merge(i.common,i[t.method]);i&&n.forEach(["delete","get","head","post","put","patch","common"],Q=>{delete i[Q]}),t.headers=m.concat(g,i);let a=[],E=!0;this.interceptors.request.forEach(function(f){if(typeof f.runWhen=="function"&&f.runWhen(t)===!1)return;E=E&&f.synchronous;let l=t.transitional||rA;l&&l.legacyInterceptorReqResOrdering?a.unshift(f.fulfilled,f.rejected):a.push(f.fulfilled,f.rejected)});let C=[];this.interceptors.response.forEach(function(f){C.push(f.fulfilled,f.rejected)});let o,s=0,c;if(!E){let Q=[jA.bind(this),void 0];for(Q.unshift(...a),Q.push(...C),c=Q.length,o=Promise.resolve(t);s<c;)o=o.then(Q[s++],Q[s++]);return o}c=a.length;let B=t;for(;s<c;){let Q=a[s++],f=a[s++];try{B=Q(B)}catch(l){f.call(this,l);break}}try{o=jA.call(this,B)}catch(Q){return Promise.reject(Q)}for(s=0,c=C.length;s<c;)o=o.then(C[s++],C[s++]);return o}getUri(e){e=Y(this.defaults,e);let t=hA(e.baseURL,e.url,e.allowAbsoluteUrls);return cA(t,e.params,e.paramsSerializer)}};n.forEach(["delete","get","head","options"],function(e){nA.prototype[e]=function(t,I){return this.request(Y(I||{},{method:e,url:t,data:(I||{}).data}))}});n.forEach(["post","put","patch"],function(e){function t(I){return function(i,g,a){return this.request(Y(a||{},{method:e,headers:I?{"Content-Type":"multipart/form-data"}:{},url:i,data:g}))}}nA.prototype[e]=t(),nA.prototype[e+"Form"]=t(!0)});var yA=nA;var Fe=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(a=>{I.subscribe(a),i=a}).then(r);return g.cancel=function(){I.unsubscribe(i)},g},e(function(i,g,a){I.reason||(I.reason=new K(i,g,a),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)}toAbortSignal(){let e=new AbortController,t=I=>{e.abort(I)};return this.subscribe(t),e.signal.unsubscribe=()=>this.unsubscribe(t),e.signal}static source(){let e;return{token:new A(function(r){e=r}),cancel:e}}},kt=Fe;function Ue(A){return function(t){return A.apply(null,t)}}function ke(A){return n.isObject(A)&&A.isAxiosError===!0}var Ne={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,WebServerIsDown:521,ConnectionTimedOut:522,OriginIsUnreachable:523,TimeoutOccurred:524,SslHandshakeFailed:525,InvalidSslCertificate:526};Object.entries(Ne).forEach(([A,e])=>{Ne[e]=A});var Nt=Ne;function Gt(A){let e=new yA(A),t=BA(yA.prototype.request,e);return n.extend(t,yA.prototype,e,{allOwnKeys:!0}),n.extend(t,e,null,{allOwnKeys:!0}),t.create=function(r){return Gt(Y(A,r))},t}var y=Gt(iA);y.Axios=yA;y.CanceledError=K;y.CancelToken=kt;y.isCancel=dA;y.VERSION=vA;y.toFormData=v;y.AxiosError=u;y.Cancel=y.CanceledError;y.all=function(e){return Promise.all(e)};y.spread=Ue;y.isAxiosError=ke;y.mergeConfig=Y;y.AxiosHeaders=m;y.formToJSON=A=>KA(n.isHTMLForm(A)?new FormData(A):A);y.getAdapter=WA.getAdapter;y.HttpStatusCode=Nt;y.default=y;var aA=y;var{Axios:mn,AxiosError:Sn,CanceledError:Rn,isCancel:Fn,CancelToken:Un,VERSION:kn,all:Nn,Cancel:Gn,isAxiosError:bn,spread:Ln,toFormData:Jn,AxiosHeaders:Hn,HttpStatusCode:Mn,formToJSON:Yn,getAdapter:qn,mergeConfig:On}=aA;async function Lr(A,e){let t=A,I=null;if(t==null)I=new Worker(new URL("./web-workers/itk-wasm-pipeline.worker.js",import.meta.url),{type:"module"});else if(t.startsWith("http")){let r=await aA.get(t,{responseType:"blob",params:e}),i=URL.createObjectURL(r.data);I=new Worker(i,{type:"module"})}else I=new Worker(t,{type:"module"});return I}var wA=Lr;function bt(A){let e=ie(A),t=A;return t.terminated=!1,t.workerProxy=e,t.originalTerminate=t.terminate,t.terminate=()=>{t.terminated=!0,t.workerProxy[re](),t.originalTerminate()},{workerProxy:e,worker:t}}async function Jr(A,e,t){let I;if(A!=null){let i=A;return i.workerProxy!==void 0?(I=i.workerProxy,{workerProxy:I,worker:i}):bt(A)}let r=await wA(e,t);return bt(r)}var Lt=Jr;var mA,x,be,Ge={env:{emscripten_notify_memory_growth:function(A){be=new Uint8Array(x.exports.memory.buffer)}}},_A=class{init(){return mA||(typeof fetch<"u"?mA=fetch("data:application/wasm;base64,"+Jt).then(e=>e.arrayBuffer()).then(e=>WebAssembly.instantiate(e,Ge)).then(this._init):mA=WebAssembly.instantiate(Buffer.from(Jt,"base64"),Ge).then(this._init),mA)}_init(e){x=e.instance,Ge.env.emscripten_notify_memory_growth(0)}decode(e,t=0){if(!x)throw new Error("ZSTDDecoder: Await .init() before decoding.");let I=e.byteLength,r=x.exports.malloc(I);be.set(e,r),t=t||Number(x.exports.ZSTD_findDecompressedSize(r,I));let i=x.exports.malloc(t),g=x.exports.ZSTD_decompress(i,t,r,I),a=be.slice(i,i+g);return x.exports.free(r),x.exports.free(i),a}},Jt="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";var Ht=new _A,Mt=!1;async function Hr(A,e,t){let I="unknown";typeof A!="string"?I=A.href:A.startsWith("http")?I=A:I=typeof e<"u"?`${e}/${A}`:A,I.endsWith(".js")&&(I=I.substring(0,I.length-3)),I.endsWith(".wasm")&&(I=I.substring(0,I.length-5)),I.endsWith(".wasm.zst")&&(I=I.substring(0,I.length-9));let r=`${I}.wasm`,i=await aA.get(`${r}.zst`,{responseType:"arraybuffer",params:t});Mt||(await Ht.init(),Mt=!0);let a=Ht.decode(new Uint8Array(i.data)).buffer;return(await import(`${I}.js`)).default({wasmBinary:a})}var Yt=Hr;var qt=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 Tt=typeof globalThis.SharedArrayBuffer=="function",Ot=new TextEncoder,Kt=new TextDecoder("utf-8");function Mr(A,e){let t={flags:"r",encoding:"binary"},I=A.fs_open(e,t.flags),i=A.fs_stat(e).size,g=null;Tt?g=new SharedArrayBuffer(i):g=new ArrayBuffer(i);let a=new Uint8Array(g);return A.fs_read(I,a,0,i,0),A.fs_close(I),a}function Pt(A,e,t){let I=null;Tt?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 w(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 Z(A,e,t){let I=JSON.stringify(e),r=A.lengthBytesUTF8(I)+1,i=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,r]);A.stringToUTF8(I,i,r)}function S(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=Pt(A,r,i);return O(I,g.buffer)}function SA(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e]),I=A.UTF8ToString(t);return JSON.parse(I)}function Yr(A,e,t,I){I!=null&&I.length>0&&I.forEach(function(C,o){switch(C.type){case d.TextStream:{let s=Ot.encode(C.data.data),c=w(A,s,o,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${c}`};Z(A,B,o);break}case d.JsonCompatible:{let s=Ot.encode(JSON.stringify(C.data)),c=w(A,s,o,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${c}`};Z(A,B,o);break}case d.BinaryStream:{let s=C.data.data,c=w(A,s,o,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${c}`};Z(A,B,o);break}case d.TextFile:{A.fs_writeFile(C.data.path,C.data.data);break}case d.BinaryFile:{A.fs_writeFile(C.data.path,C.data.data);break}case d.Image:{let s=C.data,c=w(A,s.data,o,0),B=w(A,s.direction,o,1),Q=typeof s.metadata?.entries<"u"?Array.from(s.metadata.entries()):[],f={imageType:s.imageType,name:s.name,origin:s.origin,spacing:s.spacing,direction:`data:application/vnd.itk.address,0:${B}`,size:s.size,data:`data:application/vnd.itk.address,0:${c}`,metadata:Q};Z(A,f,o);break}case d.Mesh:{let s=C.data,c=w(A,s.points,o,0),B=w(A,s.cells,o,1),Q=w(A,s.pointData,o,2),f=w(A,s.cellData,o,3),l={meshType:s.meshType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${c}`,numberOfCells:s.numberOfCells,cells:`data:application/vnd.itk.address,0:${B}`,cellBufferSize:s.cellBufferSize,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${Q}`,numberOfCellPixels:s.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${f}`};Z(A,l,o);break}case d.PointSet:{let s=C.data,c=w(A,s.points,o,0),B=w(A,s.pointData,o,1),Q={pointSetType:s.pointSetType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${c}`,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${B}`};Z(A,Q,o);break}case d.TransformList:{let s=C.data,c=[],B=0;s.forEach(Q=>{let f="",l="";Q.transformType.transformParameterization!=="Composite"&&(f=`data:application/vnd.itk.address,0:${w(A,Q.fixedParameters,o,B)}`,B+=1,l=`data:application/vnd.itk.address,0:${w(A,Q.parameters,o,B)}`,B+=1);let p={transformType:Q.transformType,numberOfFixedParameters:Q.numberOfFixedParameters,numberOfParameters:Q.numberOfParameters,name:Q.name,inputSpaceName:Q.inputSpaceName,outputSpaceName:Q.outputSpaceName,parameters:l,fixedParameters:f};c.push(p)}),Z(A,c,o);break}case d.PolyData:{let s=C.data,c=w(A,s.points,o,0),B=w(A,s.vertices,o,1),Q=w(A,s.lines,o,2),f=w(A,s.polygons,o,3),l=w(A,s.triangleStrips,o,4),p=w(A,s.pointData,o,5),R=w(A,s.pointData,o,6),D={polyDataType:s.polyDataType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${c}`,verticesBufferSize:s.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${B}`,linesBufferSize:s.linesBufferSize,lines:`data:application/vnd.itk.address,0:${Q}`,polygonsBufferSize:s.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${f}`,triangleStripsBufferSize:s.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${l}`,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${p}`,numberOfCellPixels:s.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${R}`};Z(A,D,o);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(),a=A.getModuleStderr(),E=[];return t!=null&&t.length>0&&i===0&&t.forEach(function(C,o){let s=null;switch(C.type){case d.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);s={data:Kt.decode(f)};break}case d.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);s=JSON.parse(Kt.decode(f));break}case d.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]);s={data:Pt(A,B,Q)};break}case d.TextFile:{s={path:C.data.path,data:A.fs_readFile(C.data.path,{encoding:"utf8"})};break}case d.BinaryFile:{s={path:C.data.path,data:Mr(A,C.data.path)};break}case d.Image:{let B=SA(A,o);B.data=S(A,o,0,B.imageType.componentType),B.direction=S(A,o,1,X.Float64),B.metadata=new Map(B.metadata),s=B;break}case d.Mesh:{let B=SA(A,o);B.numberOfPoints>0?B.points=S(A,o,0,B.meshType.pointComponentType):B.points=O(B.meshType.pointComponentType,new ArrayBuffer(0)),B.numberOfCells>0?B.cells=S(A,o,1,B.meshType.cellComponentType):B.cells=O(B.meshType.cellComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=S(A,o,2,B.meshType.pointPixelComponentType):B.pointData=O(B.meshType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=S(A,o,3,B.meshType.cellPixelComponentType):B.cellData=O(B.meshType.cellPixelComponentType,new ArrayBuffer(0)),s=B;break}case d.PointSet:{let B=SA(A,o);B.numberOfPoints>0?B.points=S(A,o,0,B.pointSetType.pointComponentType):B.points=O(B.pointSetType.pointComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=S(A,o,1,B.pointSetType.pointPixelComponentType):B.pointData=O(B.pointSetType.pointPixelComponentType,new ArrayBuffer(0)),s=B;break}case d.TransformList:{let B=SA(A,o),Q=0;B.forEach((f,l)=>{f.transformType.transformParameterization!=="Composite"&&(f.numberOfFixedParameters>0&&(B[l].fixedParameters=S(A,o,Q,X.Float64)),Q+=1,f.numberOfParameters>0&&(B[l].parameters=S(A,o,Q,f.transformType.parametersValueType)),Q+=1)}),s=B;break}case d.PolyData:{let B=SA(A,o);B.numberOfPoints>0?B.points=S(A,o,0,X.Float32):B.points=new Float32Array,B.verticesBufferSize>0?B.vertices=S(A,o,1,N.UInt32):B.vertices=new Uint32Array,B.linesBufferSize>0?B.lines=S(A,o,2,N.UInt32):B.lines=new Uint32Array,B.polygonsBufferSize>0?B.polygons=S(A,o,3,N.UInt32):B.polygons=new Uint32Array,B.triangleStripsBufferSize>0?B.triangleStrips=S(A,o,4,N.UInt32):B.triangleStrips=new Uint32Array,B.numberOfPointPixels>0?B.pointData=S(A,o,5,B.polyDataType.pointPixelComponentType):B.pointData=O(B.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=S(A,o,6,B.polyDataType.cellPixelComponentType):B.cellData=O(B.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),s=B;break}default:throw Error("Unsupported output InterfaceType")}let c={type:C.type,data:s};E.push(c)}),{returnValue:i,stdout:g,stderr:a,outputs:E}}var xt=Yr;var qr=typeof globalThis.SharedArrayBuffer<"u";function Or(A,e){if(A==null)return[];let t=[];for(let I=0;I<A.length;I++){let r=Kr(A[I],e);r!==null&&t.push(r)}return t}function Kr(A,e){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),qr&&t instanceof SharedArrayBuffer?null:e?t:t.slice(0)}var Wt=Or;function Tr(A){return[A.data,A.direction]}var jt=Tr;function Pr(A){return[A.points,A.pointData,A.cells,A.cellData]}var vt=Pr;function xr(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var Zt=xr;var Wr;function VA(){return Wr}var jr;function _t(){return jr}var vr;function XA(){return vr}var Le=new Map;function Zr(){let A=XA();return typeof A>"u"&&(A=null),A}function Vt(){let A=VA();return typeof A>"u"&&(A=new URL("/pipelines",document.location.origin).href),A}function zA(){let A=_t();return typeof A>"u"&&(A={}),A}async function _r(A,e,t){let I=A,r=A;if(typeof A!="string"&&(I=new URL(A.href),r=I.href),Le.has(r))return Le.get(r);{let i=await Yt(A,e?.toString()??Vt(),t??zA());return Le.set(r,i),i}}async function Vr(A,e,t,I,r){if(!await qt()){let l="WebAssembly SIMD support is required -- please update your browser.";throw alert(l),new Error(l)}let i=r?.webWorker??null;if(i===!1){let l=await _r(A.toString(),r?.pipelineBaseUrl,r?.pipelineQueryParams??zA());return xt(l,e,t,I)}let g=i,a=r?.pipelineWorkerUrl??Zr(),E=typeof a!="string"&&typeof a?.href<"u"?a.href:a,{workerProxy:C,worker:o}=await Lt(g,E,r?.pipelineQueryParams??zA());g=o;let s=[];I!=null&&I.length>0&&I.forEach(function(l){if(l.type===d.BinaryStream){let p=l.data.data;s.push(p)}else if(l.type===d.BinaryFile){let p=l.data.data;s.push(p)}else if(l.type===d.Image){let p=l.data;p.data!==null&&s.push(...jt(p))}else if(l.type===d.Mesh){let p=l.data;s.push(...vt(p))}else if(l.type===d.PolyData){let p=l.data;s.push(...Zt(p))}});let c=r?.pipelineBaseUrl??Vt(),B=typeof c!="string"&&typeof c?.href<"u"?c.href:c,Q=I!=null?ge(I,Wt(s,r?.noCopy)):null,f=await C.runPipeline(A.toString(),B,e,t,Q,r?.pipelineQueryParams??zA());return{returnValue:f.returnValue,stdout:f.stdout,stderr:f.stderr,outputs:f.outputs,webWorker:g}}var q=Vr;var Xr=null;function Xt(){return Xr}var Je,zr=`https://cdn.jsdelivr.net/npm/@itk-wasm/downsample@${ee}/dist/pipelines`;function Ga(A){Je=A}function T(){if(typeof Je<"u")return Je;let A=VA();return typeof A<"u"?A:zr}var He,$r=null;function zt(A){He=A}function J(){if(typeof He<"u")return He;let A=XA();return typeof A<"u"?A:$r}var sA=null;async function $t(){let A=J(),e=typeof A!="string"&&typeof A?.href<"u"?A.href:A;sA=await wA(e)}function qa(A){sA=A}async function P(){if(sA!==null)return sA.terminated&&await $t(),sA;let A=Xt();return A!==null?A:(await $t(),sA)}async function Ai(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),e.shrinkFactors){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async Q=>{r.push(Q.toString())}))}e.informationOnly&&e.informationOnly&&r.push("--information-only");let a="downsample-bin-shrink",E=e?.webWorker;E===void 0&&(E=await P());let{webWorker:C,returnValue:o,stderr:s,outputs:c}=await q(a,r,t,I,{pipelineBaseUrl:T(),pipelineWorkerUrl:J(),webWorker:E,noCopy:e?.noCopy});if(o!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:c[0]?.data}}var ei=Ai;async function ti(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),e.shrinkFactors){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async Q=>{r.push(Q.toString())}))}if(e.cropRadius){if(e.cropRadius.length<2)throw new Error('"crop-radius" option must have a length > 2');r.push("--crop-radius"),await Promise.all(e.cropRadius.map(async Q=>{r.push(Q.toString())}))}let a="downsample-label-image",E=e?.webWorker;E===void 0&&(E=await P());let{webWorker:C,returnValue:o,stderr:s,outputs:c}=await q(a,r,t,I,{pipelineBaseUrl:T(),pipelineWorkerUrl:J(),webWorker:E,noCopy:e?.noCopy});if(o!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:c[0]?.data}}var Ii=ti;async function ri(A={shrinkFactors:[2,2]}){let e=[{type:d.JsonCompatible}],t=[],I=[];if(I.push("0"),I.push("--memory-io"),typeof A.shrinkFactors<"u"){if(A.shrinkFactors.length<1)throw new Error('"shrink-factors" option must have a length > 1');I.push("--shrink-factors"),await Promise.all(A.shrinkFactors.map(async c=>{I.push(c.toString())}))}let i="downsample-sigma",g=A?.webWorker;g===void 0&&(g=await P());let{webWorker:a,returnValue:E,stderr:C,outputs:o}=await q(i,I,e,t,{pipelineBaseUrl:T(),pipelineWorkerUrl:J(),webWorker:g,noCopy:A?.noCopy});if(E!==0&&C!=="")throw new Error(C);return{webWorker:a,sigma:o[0]?.data}}var ii=ri;async function gi(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),e.shrinkFactors){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async Q=>{r.push(Q.toString())}))}if(e.cropRadius){if(e.cropRadius.length<2)throw new Error('"crop-radius" option must have a length > 2');r.push("--crop-radius"),await Promise.all(e.cropRadius.map(async Q=>{r.push(Q.toString())}))}let a="downsample",E=e?.webWorker;E===void 0&&(E=await P());let{webWorker:C,returnValue:o,stderr:s,outputs:c}=await q(a,r,t,I,{pipelineBaseUrl:T(),pipelineWorkerUrl:J(),webWorker:E,noCopy:e?.noCopy});if(o!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:c[0]?.data}}var oi=gi;async function ni(A={size:[1,1],sigma:[1,1]}){let e=[{type:d.JsonCompatible}],t=[],I=[];if(I.push("0"),I.push("--memory-io"),typeof A.size<"u"){if(A.size.length<1)throw new Error('"size" option must have a length > 1');I.push("--size"),await Promise.all(A.size.map(async c=>{I.push(c.toString())}))}if(typeof A.sigma<"u"){if(A.sigma.length<1)throw new Error('"sigma" option must have a length > 1');I.push("--sigma"),await Promise.all(A.sigma.map(async c=>{I.push(c.toString())}))}typeof A.maxKernelWidth<"u"&&I.push("--max-kernel-width",A.maxKernelWidth.toString()),typeof A.maxKernelError<"u"&&I.push("--max-kernel-error",A.maxKernelError.toString());let i="gaussian-kernel-radius",g=A?.webWorker;g===void 0&&(g=await P());let{webWorker:a,returnValue:E,stderr:C,outputs:o}=await q(i,I,e,t,{pipelineBaseUrl:T(),pipelineWorkerUrl:J(),webWorker:g,noCopy:A?.noCopy});if(E!==0&&C!=="")throw new Error(C);return{webWorker:a,radius:o[0]?.data}}var ai=ni;var AI='data:text/javascript;charset=utf-8,var Je=Object.defineProperty;var He=(A,t)=>{for(var e in t)Je(A,e,{get:t[e],enumerable:!0})};var Gt=Symbol("Comlink.proxy"),Ye=Symbol("Comlink.endpoint"),qe=Symbol("Comlink.releaseProxy"),_A=Symbol("Comlink.finalizer"),wA=Symbol("Comlink.thrown"),kt=A=>typeof A=="object"&&A!==null||typeof A=="function",Me={canHandle:A=>kt(A)&&A[Gt],serialize(A){let{port1:t,port2:e}=new MessageChannel;return RA(A,t),[e,[e]]},deserialize(A){return A.start(),Pe(A)}},Oe={canHandle:A=>kt(A)&&wA in A,serialize({value:A}){let t;return A instanceof Error?t={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:t={isError:!1,value:A},[t,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},Lt=new Map([["proxy",Me],["throw",Oe]]);function Te(A,t){for(let e of A)if(t===e||e==="*"||e instanceof RegExp&&e.test(t))return!0;return!1}function RA(A,t=globalThis,e=["*"]){t.addEventListener("message",function I(r){if(!r||!r.data)return;if(!Te(e,r.origin)){console.warn(`Invalid origin \'${r.origin}\' for comlink proxy`);return}let{id:o,type:g,path:s}=Object.assign({path:[]},r.data),E=(r.data.argumentList||[]).map(Z),B;try{let i=s.slice(0,-1).reduce((l,a)=>l[a],A),C=s.reduce((l,a)=>l[a],A);switch(g){case"GET":B=C;break;case"SET":i[s.slice(-1)[0]]=Z(r.data.value),B=!0;break;case"APPLY":B=C.apply(i,E);break;case"CONSTRUCT":{let l=new C(...E);B=Ze(l)}break;case"ENDPOINT":{let{port1:l,port2:a}=new MessageChannel;RA(A,a),B=XA(l,[l])}break;case"RELEASE":B=void 0;break;default:return}}catch(i){B={value:i,[wA]:0}}Promise.resolve(B).catch(i=>({value:i,[wA]:0})).then(i=>{let[C,l]=FA(i);t.postMessage(Object.assign(Object.assign({},C),{id:o}),l),g==="RELEASE"&&(t.removeEventListener("message",I),bt(t),_A in A&&typeof A[_A]=="function"&&A[_A]())}).catch(i=>{let[C,l]=FA({value:new TypeError("Unserializable return value"),[wA]:0});t.postMessage(Object.assign(Object.assign({},C),{id:o}),l)})}),t.start&&t.start()}function Ke(A){return A.constructor.name==="MessagePort"}function bt(A){Ke(A)&&A.close()}function Pe(A,t){return VA(A,[],t)}function mA(A){if(A)throw new Error("Proxy has been released and is not useable")}function Jt(A){return z(A,{type:"RELEASE"}).then(()=>{bt(A)})}var pA=new WeakMap,SA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let t=(pA.get(A)||0)-1;pA.set(A,t),t===0&&Jt(A)});function xe(A,t){let e=(pA.get(t)||0)+1;pA.set(t,e),SA&&SA.register(A,t,A)}function je(A){SA&&SA.unregister(A)}function VA(A,t=[],e=function(){}){let I=!1,r=new Proxy(e,{get(o,g){if(mA(I),g===qe)return()=>{je(r),Jt(A),I=!0};if(g==="then"){if(t.length===0)return{then:()=>r};let s=z(A,{type:"GET",path:t.map(E=>E.toString())}).then(Z);return s.then.bind(s)}return VA(A,[...t,g])},set(o,g,s){mA(I);let[E,B]=FA(s);return z(A,{type:"SET",path:[...t,g].map(i=>i.toString()),value:E},B).then(Z)},apply(o,g,s){mA(I);let E=t[t.length-1];if(E===Ye)return z(A,{type:"ENDPOINT"}).then(Z);if(E==="bind")return VA(A,t.slice(0,-1));let[B,i]=Ut(s);return z(A,{type:"APPLY",path:t.map(C=>C.toString()),argumentList:B},i).then(Z)},construct(o,g){mA(I);let[s,E]=Ut(g);return z(A,{type:"CONSTRUCT",path:t.map(B=>B.toString()),argumentList:s},E).then(Z)}});return xe(r,A),r}function We(A){return Array.prototype.concat.apply([],A)}function Ut(A){let t=A.map(FA);return[t.map(e=>e[0]),We(t.map(e=>e[1]))]}var Ht=new WeakMap;function XA(A,t){return Ht.set(A,t),A}function Ze(A){return Object.assign(A,{[Gt]:!0})}function FA(A){for(let[t,e]of Lt)if(e.canHandle(A)){let[I,r]=e.serialize(A);return[{type:"HANDLER",name:t,value:I},r]}return[{type:"RAW",value:A},Ht.get(A)||[]]}function Z(A){switch(A.type){case"HANDLER":return Lt.get(A.name).deserialize(A.value);case"RAW":return A.value}}function z(A,t,e){return new Promise(I=>{let r=_e();A.addEventListener("message",function o(g){!g.data||!g.data.id||g.data.id!==r||(A.removeEventListener("message",o),I(g.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:r},t),e)})}function _e(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function gA(A,t){return function(){return A.apply(t,arguments)}}var{toString:Ve}=Object.prototype,{getPrototypeOf:vA}=Object,{iterator:UA,toStringTag:Mt}=Symbol,GA=(A=>t=>{let e=Ve.call(t);return A[e]||(A[e]=e.slice(8,-1).toLowerCase())})(Object.create(null)),H=A=>(A=A.toLowerCase(),t=>GA(t)===A),kA=A=>t=>typeof t===A,{isArray:$}=Array,v=kA("undefined");function iA(A){return A!==null&&!v(A)&&A.constructor!==null&&!v(A.constructor)&&G(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var Ot=H("ArrayBuffer");function Xe(A){let t;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?t=ArrayBuffer.isView(A):t=A&&A.buffer&&Ot(A.buffer),t}var ze=kA("string"),G=kA("function"),Tt=kA("number"),nA=A=>A!==null&&typeof A=="object",ve=A=>A===!0||A===!1,NA=A=>{if(GA(A)!=="object")return!1;let t=vA(A);return(t===null||t===Object.prototype||Object.getPrototypeOf(t)===null)&&!(Mt in A)&&!(UA in A)},$e=A=>{if(!nA(A)||iA(A))return!1;try{return Object.keys(A).length===0&&Object.getPrototypeOf(A)===Object.prototype}catch{return!1}},AI=H("Date"),tI=H("File"),eI=H("Blob"),II=H("FileList"),rI=A=>nA(A)&&G(A.pipe),oI=A=>{let t;return A&&(typeof FormData=="function"&&A instanceof FormData||G(A.append)&&((t=GA(A))==="formdata"||t==="object"&&G(A.toString)&&A.toString()==="[object FormData]"))},gI=H("URLSearchParams"),[iI,nI,sI,CI]=["ReadableStream","Request","Response","Headers"].map(H),BI=A=>A.trim?A.trim():A.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,"");function sA(A,t,{allOwnKeys:e=!1}={}){if(A===null||typeof A>"u")return;let I,r;if(typeof A!="object"&&(A=[A]),$(A))for(I=0,r=A.length;I<r;I++)t.call(null,A[I],I,A);else{if(iA(A))return;let o=e?Object.getOwnPropertyNames(A):Object.keys(A),g=o.length,s;for(I=0;I<g;I++)s=o[I],t.call(null,A[s],s,A)}}function Kt(A,t){if(iA(A))return null;t=t.toLowerCase();let e=Object.keys(A),I=e.length,r;for(;I-- >0;)if(r=e[I],t===r.toLowerCase())return r;return null}var _=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,Pt=A=>!v(A)&&A!==_;function zA(){let{caseless:A,skipUndefined:t}=Pt(this)&&this||{},e={},I=(r,o)=>{if(o==="__proto__"||o==="constructor"||o==="prototype")return;let g=A&&Kt(e,o)||o;NA(e[g])&&NA(r)?e[g]=zA(e[g],r):NA(r)?e[g]=zA({},r):$(r)?e[g]=r.slice():(!t||!v(r))&&(e[g]=r)};for(let r=0,o=arguments.length;r<o;r++)arguments[r]&&sA(arguments[r],I);return e}var aI=(A,t,e,{allOwnKeys:I}={})=>(sA(t,(r,o)=>{e&&G(r)?Object.defineProperty(A,o,{value:gA(r,e),writable:!0,enumerable:!0,configurable:!0}):Object.defineProperty(A,o,{value:r,writable:!0,enumerable:!0,configurable:!0})},{allOwnKeys:I}),A),QI=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),EI=(A,t,e,I)=>{A.prototype=Object.create(t.prototype,I),Object.defineProperty(A.prototype,"constructor",{value:A,writable:!0,enumerable:!1,configurable:!0}),Object.defineProperty(A,"super",{value:t.prototype}),e&&Object.assign(A.prototype,e)},cI=(A,t,e,I)=>{let r,o,g,s={};if(t=t||{},A==null)return t;do{for(r=Object.getOwnPropertyNames(A),o=r.length;o-- >0;)g=r[o],(!I||I(g,A,t))&&!s[g]&&(t[g]=A[g],s[g]=!0);A=e!==!1&&vA(A)}while(A&&(!e||e(A,t))&&A!==Object.prototype);return t},fI=(A,t,e)=>{A=String(A),(e===void 0||e>A.length)&&(e=A.length),e-=t.length;let I=A.indexOf(t,e);return I!==-1&&I===e},lI=A=>{if(!A)return null;if($(A))return A;let t=A.length;if(!Tt(t))return null;let e=new Array(t);for(;t-- >0;)e[t]=A[t];return e},uI=(A=>t=>A&&t instanceof A)(typeof Uint8Array<"u"&&vA(Uint8Array)),dI=(A,t)=>{let I=(A&&A[UA]).call(A),r;for(;(r=I.next())&&!r.done;){let o=r.value;t.call(A,o[0],o[1])}},DI=(A,t)=>{let e,I=[];for(;(e=A.exec(t))!==null;)I.push(e);return I},hI=H("HTMLFormElement"),yI=A=>A.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,function(e,I,r){return I.toUpperCase()+r}),qt=(({hasOwnProperty:A})=>(t,e)=>A.call(t,e))(Object.prototype),mI=H("RegExp"),xt=(A,t)=>{let e=Object.getOwnPropertyDescriptors(A),I={};sA(e,(r,o)=>{let g;(g=t(r,o,A))!==!1&&(I[o]=g||r)}),Object.defineProperties(A,I)},wI=A=>{xt(A,(t,e)=>{if(G(A)&&["arguments","caller","callee"].indexOf(e)!==-1)return!1;let I=A[e];if(G(I)){if(t.enumerable=!1,"writable"in t){t.writable=!1;return}t.set||(t.set=()=>{throw Error("Can not rewrite read-only method \'"+e+"\'")})}})},pI=(A,t)=>{let e={},I=r=>{r.forEach(o=>{e[o]=!0})};return $(A)?I(A):I(String(A).split(t)),e},SI=()=>{},FI=(A,t)=>A!=null&&Number.isFinite(A=+A)?A:t;function RI(A){return!!(A&&G(A.append)&&A[Mt]==="FormData"&&A[UA])}var NI=A=>{let t=new Array(10),e=(I,r)=>{if(nA(I)){if(t.indexOf(I)>=0)return;if(iA(I))return I;if(!("toJSON"in I)){t[r]=I;let o=$(I)?[]:{};return sA(I,(g,s)=>{let E=e(g,r+1);!v(E)&&(o[s]=E)}),t[r]=void 0,o}}return I};return e(A,0)},UI=H("AsyncFunction"),GI=A=>A&&(nA(A)||G(A))&&G(A.then)&&G(A.catch),jt=((A,t)=>A?setImmediate:t?((e,I)=>(_.addEventListener("message",({source:r,data:o})=>{r===_&&o===e&&I.length&&I.shift()()},!1),r=>{I.push(r),_.postMessage(e,"*")}))(`axios@${Math.random()}`,[]):e=>setTimeout(e))(typeof setImmediate=="function",G(_.postMessage)),kI=typeof queueMicrotask<"u"?queueMicrotask.bind(_):typeof process<"u"&&process.nextTick||jt,LI=A=>A!=null&&G(A[UA]),n={isArray:$,isArrayBuffer:Ot,isBuffer:iA,isFormData:oI,isArrayBufferView:Xe,isString:ze,isNumber:Tt,isBoolean:ve,isObject:nA,isPlainObject:NA,isEmptyObject:$e,isReadableStream:iI,isRequest:nI,isResponse:sI,isHeaders:CI,isUndefined:v,isDate:AI,isFile:tI,isBlob:eI,isRegExp:mI,isFunction:G,isStream:rI,isURLSearchParams:gI,isTypedArray:uI,isFileList:II,forEach:sA,merge:zA,extend:aI,trim:BI,stripBOM:QI,inherits:EI,toFlatObject:cI,kindOf:GA,kindOfTest:H,endsWith:fI,toArray:lI,forEachEntry:dI,matchAll:DI,isHTMLForm:hI,hasOwnProperty:qt,hasOwnProp:qt,reduceDescriptors:xt,freezeMethods:wI,toObjectSet:pI,toCamelCase:yI,noop:SI,toFiniteNumber:FI,findKey:Kt,global:_,isContextDefined:Pt,isSpecCompliantForm:RI,toJSONObject:NI,isAsyncFn:UI,isThenable:GI,setImmediate:jt,asap:kI,isIterable:LI};var R=class A extends Error{static from(t,e,I,r,o,g){let s=new A(t.message,e||t.code,I,r,o);return s.cause=t,s.name=t.name,g&&Object.assign(s,g),s}constructor(t,e,I,r,o){super(t),this.name="AxiosError",this.isAxiosError=!0,e&&(this.code=e),I&&(this.config=I),r&&(this.request=r),o&&(this.response=o,this.status=o.status)}toJSON(){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:n.toJSONObject(this.config),code:this.code,status:this.status}}};R.ERR_BAD_OPTION_VALUE="ERR_BAD_OPTION_VALUE";R.ERR_BAD_OPTION="ERR_BAD_OPTION";R.ECONNABORTED="ECONNABORTED";R.ETIMEDOUT="ETIMEDOUT";R.ERR_NETWORK="ERR_NETWORK";R.ERR_FR_TOO_MANY_REDIRECTS="ERR_FR_TOO_MANY_REDIRECTS";R.ERR_DEPRECATED="ERR_DEPRECATED";R.ERR_BAD_RESPONSE="ERR_BAD_RESPONSE";R.ERR_BAD_REQUEST="ERR_BAD_REQUEST";R.ERR_CANCELED="ERR_CANCELED";R.ERR_NOT_SUPPORT="ERR_NOT_SUPPORT";R.ERR_INVALID_URL="ERR_INVALID_URL";var u=R;var LA=null;function $A(A){return n.isPlainObject(A)||n.isArray(A)}function Zt(A){return n.endsWith(A,"[]")?A.slice(0,-2):A}function Wt(A,t,e){return A?A.concat(t).map(function(r,o){return r=Zt(r),!e&&o?"["+r+"]":r}).join(e?".":""):t}function bI(A){return n.isArray(A)&&!A.some($A)}var JI=n.toFlatObject(n,{},null,function(t){return/^is[A-Z]/.test(t)});function HI(A,t,e){if(!n.isObject(A))throw new TypeError("target must be an object");t=t||new(LA||FormData),e=n.toFlatObject(e,{metaTokens:!0,dots:!1,indexes:!1},!1,function(f,c){return!n.isUndefined(c[f])});let I=e.metaTokens,r=e.visitor||i,o=e.dots,g=e.indexes,E=(e.Blob||typeof Blob<"u"&&Blob)&&n.isSpecCompliantForm(t);if(!n.isFunction(r))throw new TypeError("visitor must be a function");function B(Q){if(Q===null)return"";if(n.isDate(Q))return Q.toISOString();if(n.isBoolean(Q))return Q.toString();if(!E&&n.isBlob(Q))throw new u("Blob is not supported. Use a Buffer instead.");return n.isArrayBuffer(Q)||n.isTypedArray(Q)?E&&typeof Blob=="function"?new Blob([Q]):Buffer.from(Q):Q}function i(Q,f,c){let D=Q;if(Q&&!c&&typeof Q=="object"){if(n.endsWith(f,"{}"))f=I?f:f.slice(0,-2),Q=JSON.stringify(Q);else if(n.isArray(Q)&&bI(Q)||(n.isFileList(Q)||n.endsWith(f,"[]"))&&(D=n.toArray(Q)))return f=Zt(f),D.forEach(function(y,N){!(n.isUndefined(y)||y===null)&&t.append(g===!0?Wt([f],N,o):g===null?f:f+"[]",B(y))}),!1}return $A(Q)?!0:(t.append(Wt(c,f,o),B(Q)),!1)}let C=[],l=Object.assign(JI,{defaultVisitor:i,convertValue:B,isVisitable:$A});function a(Q,f){if(!n.isUndefined(Q)){if(C.indexOf(Q)!==-1)throw Error("Circular reference detected in "+f.join("."));C.push(Q),n.forEach(Q,function(D,F){(!(n.isUndefined(D)||D===null)&&r.call(t,D,n.isString(F)?F.trim():F,f,l))===!0&&a(D,f?f.concat(F):[F])}),C.pop()}}if(!n.isObject(A))throw new TypeError("data must be an object");return a(A),t}var P=HI;function _t(A){let t={"!":"%2521","\'":"%2527","(":"%2528",")":"%2529","~":"%257E","%2520":"+","%2500":"\\0"};return encodeURIComponent(A).replace(/[!\'()~]|%2520|%2500/g,function(I){return t[I]})}function Vt(A,t){this._pairs=[],A&&P(A,this,t)}var Xt=Vt.prototype;Xt.append=function(t,e){this._pairs.push([t,e])};Xt.toString=function(t){let e=t?function(I){return t.call(this,I,_t)}:_t;return this._pairs.map(function(r){return e(r[0])+"="+e(r[1])},"").join("&")};var bA=Vt;function YI(A){return encodeURIComponent(A).replace(/%253A/gi,":").replace(/%2524/g,"$").replace(/%252C/gi,",").replace(/%2520/g,"+")}function CA(A,t,e){if(!t)return A;let I=e&&e.encode||YI,r=n.isFunction(e)?{serialize:e}:e,o=r&&r.serialize,g;if(o?g=o(t,r):g=n.isURLSearchParams(t)?t.toString():new bA(t,r).toString(I),g){let s=A.indexOf("%23");s!==-1&&(A=A.slice(0,s)),A+=(A.indexOf("?")===-1?"?":"&")+g}return A}var At=class{constructor(){this.handlers=[]}use(t,e,I){return this.handlers.push({fulfilled:t,rejected:e,synchronous:I?I.synchronous:!1,runWhen:I?I.runWhen:null}),this.handlers.length-1}eject(t){this.handlers[t]&&(this.handlers[t]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(t){n.forEach(this.handlers,function(I){I!==null&&t(I)})}},tt=At;var AA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1,legacyInterceptorReqResOrdering:!0};var zt=typeof URLSearchParams<"u"?URLSearchParams:bA;var vt=typeof FormData<"u"?FormData:null;var $t=typeof Blob<"u"?Blob:null;var Ae={isBrowser:!0,classes:{URLSearchParams:zt,FormData:vt,Blob:$t},protocols:["http","https","file","blob","url","data"]};var rt={};He(rt,{hasBrowserEnv:()=>It,hasStandardBrowserEnv:()=>qI,hasStandardBrowserWebWorkerEnv:()=>MI,navigator:()=>et,origin:()=>OI});var It=typeof window<"u"&&typeof document<"u",et=typeof navigator=="object"&&navigator||void 0,qI=It&&(!et||["ReactNative","NativeScript","NS"].indexOf(et.product)<0),MI=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function",OI=It&&window.location.href||"http://localhost";var h={...rt,...Ae};function ot(A,t){return P(A,new h.classes.URLSearchParams,{visitor:function(e,I,r,o){return h.isNode&&n.isBuffer(e)?(this.append(I,e.toString("base64")),!1):o.defaultVisitor.apply(this,arguments)},...t})}function TI(A){return n.matchAll(/\\w+|\\[(\\w*)]/g,A).map(t=>t[0]==="[]"?"":t[1]||t[0])}function KI(A){let t={},e=Object.keys(A),I,r=e.length,o;for(I=0;I<r;I++)o=e[I],t[o]=A[o];return t}function PI(A){function t(e,I,r,o){let g=e[o++];if(g==="__proto__")return!0;let s=Number.isFinite(+g),E=o>=e.length;return g=!g&&n.isArray(r)?r.length:g,E?(n.hasOwnProp(r,g)?r[g]=[r[g],I]:r[g]=I,!s):((!r[g]||!n.isObject(r[g]))&&(r[g]=[]),t(e,I,r[g],o)&&n.isArray(r[g])&&(r[g]=KI(r[g])),!s)}if(n.isFormData(A)&&n.isFunction(A.entries)){let e={};return n.forEachEntry(A,(I,r)=>{t(TI(I),r,e,0)}),e}return null}var JA=PI;function xI(A,t,e){if(n.isString(A))try{return(t||JSON.parse)(A),n.trim(A)}catch(I){if(I.name!=="SyntaxError")throw I}return(e||JSON.stringify)(A)}var gt={transitional:AA,adapter:["xhr","http","fetch"],transformRequest:[function(t,e){let I=e.getContentType()||"",r=I.indexOf("application/json")>-1,o=n.isObject(t);if(o&&n.isHTMLForm(t)&&(t=new FormData(t)),n.isFormData(t))return r?JSON.stringify(JA(t)):t;if(n.isArrayBuffer(t)||n.isBuffer(t)||n.isStream(t)||n.isFile(t)||n.isBlob(t)||n.isReadableStream(t))return t;if(n.isArrayBufferView(t))return t.buffer;if(n.isURLSearchParams(t))return e.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),t.toString();let s;if(o){if(I.indexOf("application/x-www-form-urlencoded")>-1)return ot(t,this.formSerializer).toString();if((s=n.isFileList(t))||I.indexOf("multipart/form-data")>-1){let E=this.env&&this.env.FormData;return P(s?{"files[]":t}:t,E&&new E,this.formSerializer)}}return o||r?(e.setContentType("application/json",!1),xI(t)):t}],transformResponse:[function(t){let e=this.transitional||gt.transitional,I=e&&e.forcedJSONParsing,r=this.responseType==="json";if(n.isResponse(t)||n.isReadableStream(t))return t;if(t&&n.isString(t)&&(I&&!this.responseType||r)){let g=!(e&&e.silentJSONParsing)&&r;try{return JSON.parse(t,this.parseReviver)}catch(s){if(g)throw s.name==="SyntaxError"?u.from(s,u.ERR_BAD_RESPONSE,this,null,this.response):s}}return t}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:h.classes.FormData,Blob:h.classes.Blob},validateStatus:function(t){return t>=200&&t<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};n.forEach(["delete","get","head","post","put","patch"],A=>{gt.headers[A]={}});var tA=gt;var jI=n.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"]),te=A=>{let t={},e,I,r;return A&&A.split(`%0A`).forEach(function(g){r=g.indexOf(":"),e=g.substring(0,r).trim().toLowerCase(),I=g.substring(r+1).trim(),!(!e||t[e]&&jI[e])&&(e==="set-cookie"?t[e]?t[e].push(I):t[e]=[I]:t[e]=t[e]?t[e]+", "+I:I)}),t};var ee=Symbol("internals");function BA(A){return A&&String(A).trim().toLowerCase()}function HA(A){return A===!1||A==null?A:n.isArray(A)?A.map(HA):String(A)}function WI(A){let t=Object.create(null),e=/([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g,I;for(;I=e.exec(A);)t[I[1]]=I[2];return t}var ZI=A=>/^[-_a-zA-Z0-9^`|~,!%23$%&\'*+.]+$/.test(A.trim());function it(A,t,e,I,r){if(n.isFunction(I))return I.call(this,t,e);if(r&&(t=e),!!n.isString(t)){if(n.isString(I))return t.indexOf(I)!==-1;if(n.isRegExp(I))return I.test(t)}}function _I(A){return A.trim().toLowerCase().replace(/([a-z\\d])(\\w*)/g,(t,e,I)=>e.toUpperCase()+I)}function VI(A,t){let e=n.toCamelCase(" "+t);["get","set","has"].forEach(I=>{Object.defineProperty(A,I+e,{value:function(r,o,g){return this[I].call(this,t,r,o,g)},configurable:!0})})}var eA=class{constructor(t){t&&this.set(t)}set(t,e,I){let r=this;function o(s,E,B){let i=BA(E);if(!i)throw new Error("header name must be a non-empty string");let C=n.findKey(r,i);(!C||r[C]===void 0||B===!0||B===void 0&&r[C]!==!1)&&(r[C||E]=HA(s))}let g=(s,E)=>n.forEach(s,(B,i)=>o(B,i,E));if(n.isPlainObject(t)||t instanceof this.constructor)g(t,e);else if(n.isString(t)&&(t=t.trim())&&!ZI(t))g(te(t),e);else if(n.isObject(t)&&n.isIterable(t)){let s={},E,B;for(let i of t){if(!n.isArray(i))throw TypeError("Object iterator must return a key-value pair");s[B=i[0]]=(E=s[B])?n.isArray(E)?[...E,i[1]]:[E,i[1]]:i[1]}g(s,e)}else t!=null&&o(e,t,I);return this}get(t,e){if(t=BA(t),t){let I=n.findKey(this,t);if(I){let r=this[I];if(!e)return r;if(e===!0)return WI(r);if(n.isFunction(e))return e.call(this,r,I);if(n.isRegExp(e))return e.exec(r);throw new TypeError("parser must be boolean|regexp|function")}}}has(t,e){if(t=BA(t),t){let I=n.findKey(this,t);return!!(I&&this[I]!==void 0&&(!e||it(this,this[I],I,e)))}return!1}delete(t,e){let I=this,r=!1;function o(g){if(g=BA(g),g){let s=n.findKey(I,g);s&&(!e||it(I,I[s],s,e))&&(delete I[s],r=!0)}}return n.isArray(t)?t.forEach(o):o(t),r}clear(t){let e=Object.keys(this),I=e.length,r=!1;for(;I--;){let o=e[I];(!t||it(this,this[o],o,t,!0))&&(delete this[o],r=!0)}return r}normalize(t){let e=this,I={};return n.forEach(this,(r,o)=>{let g=n.findKey(I,o);if(g){e[g]=HA(r),delete e[o];return}let s=t?_I(o):String(o).trim();s!==o&&delete e[o],e[s]=HA(r),I[s]=!0}),this}concat(...t){return this.constructor.concat(this,...t)}toJSON(t){let e=Object.create(null);return n.forEach(this,(I,r)=>{I!=null&&I!==!1&&(e[r]=t&&n.isArray(I)?I.join(", "):I)}),e}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([t,e])=>t+": "+e).join(`%0A`)}getSetCookie(){return this.get("set-cookie")||[]}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(t){return t instanceof this?t:new this(t)}static concat(t,...e){let I=new this(t);return e.forEach(r=>I.set(r)),I}static accessor(t){let I=(this[ee]=this[ee]={accessors:{}}).accessors,r=this.prototype;function o(g){let s=BA(g);I[s]||(VI(r,g),I[s]=!0)}return n.isArray(t)?t.forEach(o):o(t),this}};eA.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);n.reduceDescriptors(eA.prototype,({value:A},t)=>{let e=t[0].toUpperCase()+t.slice(1);return{get:()=>A,set(I){this[e]=I}}});n.freezeMethods(eA);var p=eA;function aA(A,t){let e=this||tA,I=t||e,r=p.from(I.headers),o=I.data;return n.forEach(A,function(s){o=s.call(e,o,r.normalize(),t?t.status:void 0)}),r.normalize(),o}function QA(A){return!!(A&&A.__CANCEL__)}var nt=class extends u{constructor(t,e,I){super(t??"canceled",u.ERR_CANCELED,e,I),this.name="CanceledError",this.__CANCEL__=!0}},q=nt;function EA(A,t,e){let I=e.config.validateStatus;!e.status||!I||I(e.status)?A(e):t(new u("Request failed with status code "+e.status,[u.ERR_BAD_REQUEST,u.ERR_BAD_RESPONSE][Math.floor(e.status/100)-4],e.config,e.request,e))}function st(A){let t=/^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(A);return t&&t[1]||""}function XI(A,t){A=A||10;let e=new Array(A),I=new Array(A),r=0,o=0,g;return t=t!==void 0?t:1e3,function(E){let B=Date.now(),i=I[o];g||(g=B),e[r]=E,I[r]=B;let C=o,l=0;for(;C!==r;)l+=e[C++],C=C%A;if(r=(r+1)%A,r===o&&(o=(o+1)%A),B-g<t)return;let a=i&&B-i;return a?Math.round(l*1e3/a):void 0}}var Ie=XI;function zI(A,t){let e=0,I=1e3/t,r,o,g=(B,i=Date.now())=>{e=i,r=null,o&&(clearTimeout(o),o=null),A(...B)};return[(...B)=>{let i=Date.now(),C=i-e;C>=I?g(B,i):(r=B,o||(o=setTimeout(()=>{o=null,g(r)},I-C)))},()=>r&&g(r)]}var re=zI;var IA=(A,t,e=3)=>{let I=0,r=Ie(50,250);return re(o=>{let g=o.loaded,s=o.lengthComputable?o.total:void 0,E=g-I,B=r(E),i=g<=s;I=g;let C={loaded:g,total:s,progress:s?g/s:void 0,bytes:E,rate:B||void 0,estimated:B&&s&&i?(s-g)/B:void 0,event:o,lengthComputable:s!=null,[t?"download":"upload"]:!0};A(C)},e)},Ct=(A,t)=>{let e=A!=null;return[I=>t[0]({lengthComputable:e,total:A,loaded:I}),t[1]]},Bt=A=>(...t)=>n.asap(()=>A(...t));var oe=h.hasStandardBrowserEnv?((A,t)=>e=>(e=new URL(e,h.origin),A.protocol===e.protocol&&A.host===e.host&&(t||A.port===e.port)))(new URL(h.origin),h.navigator&&/(msie|trident)/i.test(h.navigator.userAgent)):()=>!0;var ge=h.hasStandardBrowserEnv?{write(A,t,e,I,r,o,g){if(typeof document>"u")return;let s=[`${A}=${encodeURIComponent(t)}`];n.isNumber(e)&&s.push(`expires=${new Date(e).toUTCString()}`),n.isString(I)&&s.push(`path=${I}`),n.isString(r)&&s.push(`domain=${r}`),o===!0&&s.push("secure"),n.isString(g)&&s.push(`SameSite=${g}`),document.cookie=s.join("; ")},read(A){if(typeof document>"u")return null;let t=document.cookie.match(new RegExp("(?:^|; )"+A+"=([^;]*)"));return t?decodeURIComponent(t[1]):null},remove(A){this.write(A,"",Date.now()-864e5,"/")}}:{write(){},read(){return null},remove(){}};function at(A){return typeof A!="string"?!1:/^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(A)}function Qt(A,t){return t?A.replace(/\\/?\\/$/,"")+"/"+t.replace(/^\\/+/,""):A}function cA(A,t,e){let I=!at(t);return A&&(I||e==!1)?Qt(A,t):t}var ie=A=>A instanceof p?{...A}:A;function Y(A,t){t=t||{};let e={};function I(B,i,C,l){return n.isPlainObject(B)&&n.isPlainObject(i)?n.merge.call({caseless:l},B,i):n.isPlainObject(i)?n.merge({},i):n.isArray(i)?i.slice():i}function r(B,i,C,l){if(n.isUndefined(i)){if(!n.isUndefined(B))return I(void 0,B,C,l)}else return I(B,i,C,l)}function o(B,i){if(!n.isUndefined(i))return I(void 0,i)}function g(B,i){if(n.isUndefined(i)){if(!n.isUndefined(B))return I(void 0,B)}else return I(void 0,i)}function s(B,i,C){if(C in t)return I(B,i);if(C in A)return I(void 0,B)}let E={url:o,method:o,data:o,baseURL:g,transformRequest:g,transformResponse:g,paramsSerializer:g,timeout:g,timeoutMessage:g,withCredentials:g,withXSRFToken: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:s,headers:(B,i,C)=>r(ie(B),ie(i),C,!0)};return n.forEach(Object.keys({...A,...t}),function(i){if(i==="__proto__"||i==="constructor"||i==="prototype")return;let C=n.hasOwnProp(E,i)?E[i]:r,l=C(A[i],t[i],i);n.isUndefined(l)&&C!==s||(e[i]=l)}),e}var YA=A=>{let t=Y({},A),{data:e,withXSRFToken:I,xsrfHeaderName:r,xsrfCookieName:o,headers:g,auth:s}=t;if(t.headers=g=p.from(g),t.url=CA(cA(t.baseURL,t.url,t.allowAbsoluteUrls),A.params,A.paramsSerializer),s&&g.set("Authorization","Basic "+btoa((s.username||"")+":"+(s.password?unescape(encodeURIComponent(s.password)):""))),n.isFormData(e)){if(h.hasStandardBrowserEnv||h.hasStandardBrowserWebWorkerEnv)g.setContentType(void 0);else if(n.isFunction(e.getHeaders)){let E=e.getHeaders(),B=["content-type","content-length"];Object.entries(E).forEach(([i,C])=>{B.includes(i.toLowerCase())&&g.set(i,C)})}}if(h.hasStandardBrowserEnv&&(I&&n.isFunction(I)&&(I=I(t)),I||I!==!1&&oe(t.url))){let E=r&&o&&ge.read(o);E&&g.set(r,E)}return t};var vI=typeof XMLHttpRequest<"u",ne=vI&&function(A){return new Promise(function(e,I){let r=YA(A),o=r.data,g=p.from(r.headers).normalize(),{responseType:s,onUploadProgress:E,onDownloadProgress:B}=r,i,C,l,a,Q;function f(){a&&a(),Q&&Q(),r.cancelToken&&r.cancelToken.unsubscribe(i),r.signal&&r.signal.removeEventListener("abort",i)}let c=new XMLHttpRequest;c.open(r.method.toUpperCase(),r.url,!0),c.timeout=r.timeout;function D(){if(!c)return;let y=p.from("getAllResponseHeaders"in c&&c.getAllResponseHeaders()),J={data:!s||s==="text"||s==="json"?c.responseText:c.response,status:c.status,statusText:c.statusText,headers:y,config:A,request:c};EA(function(L){e(L),f()},function(L){I(L),f()},J),c=null}"onloadend"in c?c.onloadend=D:c.onreadystatechange=function(){!c||c.readyState!==4||c.status===0&&!(c.responseURL&&c.responseURL.indexOf("file:")===0)||setTimeout(D)},c.onabort=function(){c&&(I(new u("Request aborted",u.ECONNABORTED,A,c)),c=null)},c.onerror=function(N){let J=N&&N.message?N.message:"Network Error",j=new u(J,u.ERR_NETWORK,A,c);j.event=N||null,I(j),c=null},c.ontimeout=function(){let N=r.timeout?"timeout of "+r.timeout+"ms exceeded":"timeout exceeded",J=r.transitional||AA;r.timeoutErrorMessage&&(N=r.timeoutErrorMessage),I(new u(N,J.clarifyTimeoutError?u.ETIMEDOUT:u.ECONNABORTED,A,c)),c=null},o===void 0&&g.setContentType(null),"setRequestHeader"in c&&n.forEach(g.toJSON(),function(N,J){c.setRequestHeader(J,N)}),n.isUndefined(r.withCredentials)||(c.withCredentials=!!r.withCredentials),s&&s!=="json"&&(c.responseType=r.responseType),B&&([l,Q]=IA(B,!0),c.addEventListener("progress",l)),E&&c.upload&&([C,a]=IA(E),c.upload.addEventListener("progress",C),c.upload.addEventListener("loadend",a)),(r.cancelToken||r.signal)&&(i=y=>{c&&(I(!y||y.type?new q(null,A,c):y),c.abort(),c=null)},r.cancelToken&&r.cancelToken.subscribe(i),r.signal&&(r.signal.aborted?i():r.signal.addEventListener("abort",i)));let F=st(r.url);if(F&&h.protocols.indexOf(F)===-1){I(new u("Unsupported protocol "+F+":",u.ERR_BAD_REQUEST,A));return}c.send(o||null)})};var $I=(A,t)=>{let{length:e}=A=A?A.filter(Boolean):[];if(t||e){let I=new AbortController,r,o=function(B){if(!r){r=!0,s();let i=B instanceof Error?B:this.reason;I.abort(i instanceof u?i:new q(i instanceof Error?i.message:i))}},g=t&&setTimeout(()=>{g=null,o(new u(`timeout of ${t}ms exceeded`,u.ETIMEDOUT))},t),s=()=>{A&&(g&&clearTimeout(g),g=null,A.forEach(B=>{B.unsubscribe?B.unsubscribe(o):B.removeEventListener("abort",o)}),A=null)};A.forEach(B=>B.addEventListener("abort",o));let{signal:E}=I;return E.unsubscribe=()=>n.asap(s),E}},se=$I;var Ar=function*(A,t){let e=A.byteLength;if(!t||e<t){yield A;return}let I=0,r;for(;I<e;)r=I+t,yield A.slice(I,r),I=r},tr=async function*(A,t){for await(let e of er(A))yield*Ar(e,t)},er=async function*(A){if(A[Symbol.asyncIterator]){yield*A;return}let t=A.getReader();try{for(;;){let{done:e,value:I}=await t.read();if(e)break;yield I}}finally{await t.cancel()}},Et=(A,t,e,I)=>{let r=tr(A,t),o=0,g,s=E=>{g||(g=!0,I&&I(E))};return new ReadableStream({async pull(E){try{let{done:B,value:i}=await r.next();if(B){s(),E.close();return}let C=i.byteLength;if(e){let l=o+=C;e(l)}E.enqueue(new Uint8Array(i))}catch(B){throw s(B),B}},cancel(E){return s(E),r.return()}},{highWaterMark:2})};var Ce=64*1024,{isFunction:qA}=n,Ir=(({Request:A,Response:t})=>({Request:A,Response:t}))(n.global),{ReadableStream:Be,TextEncoder:ae}=n.global,Qe=(A,...t)=>{try{return!!A(...t)}catch{return!1}},rr=A=>{A=n.merge.call({skipUndefined:!0},Ir,A);let{fetch:t,Request:e,Response:I}=A,r=t?qA(t):typeof fetch=="function",o=qA(e),g=qA(I);if(!r)return!1;let s=r&&qA(Be),E=r&&(typeof ae=="function"?(Q=>f=>Q.encode(f))(new ae):async Q=>new Uint8Array(await new e(Q).arrayBuffer())),B=o&&s&&Qe(()=>{let Q=!1,f=new e(h.origin,{body:new Be,method:"POST",get duplex(){return Q=!0,"half"}}).headers.has("Content-Type");return Q&&!f}),i=g&&s&&Qe(()=>n.isReadableStream(new I("").body)),C={stream:i&&(Q=>Q.body)};r&&["text","arrayBuffer","blob","formData","stream"].forEach(Q=>{!C[Q]&&(C[Q]=(f,c)=>{let D=f&&f[Q];if(D)return D.call(f);throw new u(`Response type \'${Q}\' is not supported`,u.ERR_NOT_SUPPORT,c)})});let l=async Q=>{if(Q==null)return 0;if(n.isBlob(Q))return Q.size;if(n.isSpecCompliantForm(Q))return(await new e(h.origin,{method:"POST",body:Q}).arrayBuffer()).byteLength;if(n.isArrayBufferView(Q)||n.isArrayBuffer(Q))return Q.byteLength;if(n.isURLSearchParams(Q)&&(Q=Q+""),n.isString(Q))return(await E(Q)).byteLength},a=async(Q,f)=>{let c=n.toFiniteNumber(Q.getContentLength());return c??l(f)};return async Q=>{let{url:f,method:c,data:D,signal:F,cancelToken:y,timeout:N,onDownloadProgress:J,onUploadProgress:j,responseType:L,headers:WA,withCredentials:DA="same-origin",fetchOptions:wt}=YA(Q),pt=t||fetch;L=L?(L+"").toLowerCase():"text";let hA=se([F,y&&y.toAbortSignal()],N),oA=null,W=hA&&hA.unsubscribe&&(()=>{hA.unsubscribe()}),St;try{if(j&&B&&c!=="get"&&c!=="head"&&(St=await a(WA,D))!==0){let K=new e(f,{method:"POST",body:D,duplex:"half"}),X;if(n.isFormData(D)&&(X=K.headers.get("content-type"))&&WA.setContentType(X),K.body){let[ZA,yA]=Ct(St,IA(Bt(j)));D=Et(K.body,Ce,ZA,yA)}}n.isString(DA)||(DA=DA?"include":"omit");let U=o&&"credentials"in e.prototype,Ft={...wt,signal:hA,method:c.toUpperCase(),headers:WA.normalize().toJSON(),body:D,duplex:"half",credentials:U?DA:void 0};oA=o&&new e(f,Ft);let T=await(o?pt(oA,wt):pt(f,Ft)),Rt=i&&(L==="stream"||L==="response");if(i&&(J||Rt&&W)){let K={};["status","statusText","headers"].forEach(Nt=>{K[Nt]=T[Nt]});let X=n.toFiniteNumber(T.headers.get("content-length")),[ZA,yA]=J&&Ct(X,IA(Bt(J),!0))||[];T=new I(Et(T.body,Ce,ZA,()=>{yA&&yA(),W&&W()}),K)}L=L||"text";let be=await C[n.findKey(C,L)||"text"](T,Q);return!Rt&&W&&W(),await new Promise((K,X)=>{EA(K,X,{data:be,headers:p.from(T.headers),status:T.status,statusText:T.statusText,config:Q,request:oA})})}catch(U){throw W&&W(),U&&U.name==="TypeError"&&/Load failed|fetch/i.test(U.message)?Object.assign(new u("Network Error",u.ERR_NETWORK,Q,oA,U&&U.response),{cause:U.cause||U}):u.from(U,U&&U.code,Q,oA,U&&U.response)}}},or=new Map,ct=A=>{let t=A&&A.env||{},{fetch:e,Request:I,Response:r}=t,o=[I,r,e],g=o.length,s=g,E,B,i=or;for(;s--;)E=o[s],B=i.get(E),B===void 0&&i.set(E,B=s?new Map:rr(t)),i=B;return B},Ug=ct();var ft={http:LA,xhr:ne,fetch:{get:ct}};n.forEach(ft,(A,t)=>{if(A){try{Object.defineProperty(A,"name",{value:t})}catch{}Object.defineProperty(A,"adapterName",{value:t})}});var Ee=A=>`- ${A}`,ir=A=>n.isFunction(A)||A===null||A===!1;function nr(A,t){A=n.isArray(A)?A:[A];let{length:e}=A,I,r,o={};for(let g=0;g<e;g++){I=A[g];let s;if(r=I,!ir(I)&&(r=ft[(s=String(I)).toLowerCase()],r===void 0))throw new u(`Unknown adapter \'${s}\'`);if(r&&(n.isFunction(r)||(r=r.get(t))))break;o[s||"%23"+g]=r}if(!r){let g=Object.entries(o).map(([E,B])=>`adapter ${E} `+(B===!1?"is not supported by the environment":"is not available in the build")),s=e?g.length>1?`since :%0A`+g.map(Ee).join(`%0A`):" "+Ee(g[0]):"as no adapter specified";throw new u("There is no suitable adapter to dispatch the request "+s,"ERR_NOT_SUPPORT")}return r}var MA={getAdapter:nr,adapters:ft};function lt(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new q(null,A)}function OA(A){return lt(A),A.headers=p.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),MA.getAdapter(A.adapter||tA.adapter,A)(A).then(function(I){return lt(A),I.data=aA.call(A,A.transformResponse,I),I.headers=p.from(I.headers),I},function(I){return QA(I)||(lt(A),I&&I.response&&(I.response.data=aA.call(A,A.transformResponse,I.response),I.response.headers=p.from(I.response.headers))),Promise.reject(I)})}var TA="1.13.5";var KA={};["object","boolean","number","function","string","symbol"].forEach((A,t)=>{KA[A]=function(I){return typeof I===A||"a"+(t<1?"n ":" ")+A}});var ce={};KA.transitional=function(t,e,I){function r(o,g){return"[Axios v"+TA+"] Transitional option \'"+o+"\'"+g+(I?". "+I:"")}return(o,g,s)=>{if(t===!1)throw new u(r(g," has been removed"+(e?" in "+e:"")),u.ERR_DEPRECATED);return e&&!ce[g]&&(ce[g]=!0,console.warn(r(g," has been deprecated since v"+e+" and will be removed in the near future"))),t?t(o,g,s):!0}};KA.spelling=function(t){return(e,I)=>(console.warn(`${I} is likely a misspelling of ${t}`),!0)};function sr(A,t,e){if(typeof A!="object")throw new u("options must be an object",u.ERR_BAD_OPTION_VALUE);let I=Object.keys(A),r=I.length;for(;r-- >0;){let o=I[r],g=t[o];if(g){let s=A[o],E=s===void 0||g(s,o,A);if(E!==!0)throw new u("option "+o+" must be "+E,u.ERR_BAD_OPTION_VALUE);continue}if(e!==!0)throw new u("Unknown option "+o,u.ERR_BAD_OPTION)}}var fA={assertOptions:sr,validators:KA};var b=fA.validators,rA=class{constructor(t){this.defaults=t||{},this.interceptors={request:new tt,response:new tt}}async request(t,e){try{return await this._request(t,e)}catch(I){if(I instanceof Error){let r={};Error.captureStackTrace?Error.captureStackTrace(r):r=new Error;let o=r.stack?r.stack.replace(/^.+\\n/,""):"";try{I.stack?o&&!String(I.stack).endsWith(o.replace(/^.+\\n.+\\n/,""))&&(I.stack+=`%0A`+o):I.stack=o}catch{}}throw I}}_request(t,e){typeof t=="string"?(e=e||{},e.url=t):e=t||{},e=Y(this.defaults,e);let{transitional:I,paramsSerializer:r,headers:o}=e;I!==void 0&&fA.assertOptions(I,{silentJSONParsing:b.transitional(b.boolean),forcedJSONParsing:b.transitional(b.boolean),clarifyTimeoutError:b.transitional(b.boolean),legacyInterceptorReqResOrdering:b.transitional(b.boolean)},!1),r!=null&&(n.isFunction(r)?e.paramsSerializer={serialize:r}:fA.assertOptions(r,{encode:b.function,serialize:b.function},!0)),e.allowAbsoluteUrls!==void 0||(this.defaults.allowAbsoluteUrls!==void 0?e.allowAbsoluteUrls=this.defaults.allowAbsoluteUrls:e.allowAbsoluteUrls=!0),fA.assertOptions(e,{baseUrl:b.spelling("baseURL"),withXsrfToken:b.spelling("withXSRFToken")},!0),e.method=(e.method||this.defaults.method||"get").toLowerCase();let g=o&&n.merge(o.common,o[e.method]);o&&n.forEach(["delete","get","head","post","put","patch","common"],Q=>{delete o[Q]}),e.headers=p.concat(g,o);let s=[],E=!0;this.interceptors.request.forEach(function(f){if(typeof f.runWhen=="function"&&f.runWhen(e)===!1)return;E=E&&f.synchronous;let c=e.transitional||AA;c&&c.legacyInterceptorReqResOrdering?s.unshift(f.fulfilled,f.rejected):s.push(f.fulfilled,f.rejected)});let B=[];this.interceptors.response.forEach(function(f){B.push(f.fulfilled,f.rejected)});let i,C=0,l;if(!E){let Q=[OA.bind(this),void 0];for(Q.unshift(...s),Q.push(...B),l=Q.length,i=Promise.resolve(e);C<l;)i=i.then(Q[C++],Q[C++]);return i}l=s.length;let a=e;for(;C<l;){let Q=s[C++],f=s[C++];try{a=Q(a)}catch(c){f.call(this,c);break}}try{i=OA.call(this,a)}catch(Q){return Promise.reject(Q)}for(C=0,l=B.length;C<l;)i=i.then(B[C++],B[C++]);return i}getUri(t){t=Y(this.defaults,t);let e=cA(t.baseURL,t.url,t.allowAbsoluteUrls);return CA(e,t.params,t.paramsSerializer)}};n.forEach(["delete","get","head","options"],function(t){rA.prototype[t]=function(e,I){return this.request(Y(I||{},{method:t,url:e,data:(I||{}).data}))}});n.forEach(["post","put","patch"],function(t){function e(I){return function(o,g,s){return this.request(Y(s||{},{method:t,headers:I?{"Content-Type":"multipart/form-data"}:{},url:o,data:g}))}}rA.prototype[t]=e(),rA.prototype[t+"Form"]=e(!0)});var lA=rA;var ut=class A{constructor(t){if(typeof t!="function")throw new TypeError("executor must be a function.");let e;this.promise=new Promise(function(o){e=o});let I=this;this.promise.then(r=>{if(!I._listeners)return;let o=I._listeners.length;for(;o-- >0;)I._listeners[o](r);I._listeners=null}),this.promise.then=r=>{let o,g=new Promise(s=>{I.subscribe(s),o=s}).then(r);return g.cancel=function(){I.unsubscribe(o)},g},t(function(o,g,s){I.reason||(I.reason=new q(o,g,s),e(I.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(t){if(this.reason){t(this.reason);return}this._listeners?this._listeners.push(t):this._listeners=[t]}unsubscribe(t){if(!this._listeners)return;let e=this._listeners.indexOf(t);e!==-1&&this._listeners.splice(e,1)}toAbortSignal(){let t=new AbortController,e=I=>{t.abort(I)};return this.subscribe(e),t.signal.unsubscribe=()=>this.unsubscribe(e),t.signal}static source(){let t;return{token:new A(function(r){t=r}),cancel:t}}},fe=ut;function dt(A){return function(e){return A.apply(null,e)}}function Dt(A){return n.isObject(A)&&A.isAxiosError===!0}var ht={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,WebServerIsDown:521,ConnectionTimedOut:522,OriginIsUnreachable:523,TimeoutOccurred:524,SslHandshakeFailed:525,InvalidSslCertificate:526};Object.entries(ht).forEach(([A,t])=>{ht[t]=A});var le=ht;function ue(A){let t=new lA(A),e=gA(lA.prototype.request,t);return n.extend(e,lA.prototype,t,{allOwnKeys:!0}),n.extend(e,t,null,{allOwnKeys:!0}),e.create=function(r){return ue(Y(A,r))},e}var m=ue(tA);m.Axios=lA;m.CanceledError=q;m.CancelToken=fe;m.isCancel=QA;m.VERSION=TA;m.toFormData=P;m.AxiosError=u;m.Cancel=m.CanceledError;m.all=function(t){return Promise.all(t)};m.spread=dt;m.isAxiosError=Dt;m.mergeConfig=Y;m.AxiosHeaders=p;m.formToJSON=A=>JA(n.isHTMLForm(A)?new FormData(A):A);m.getAdapter=MA.getAdapter;m.HttpStatusCode=le;m.default=m;var PA=m;var{Axios:Ri,AxiosError:Ni,CanceledError:Ui,isCancel:Gi,CancelToken:ki,VERSION:Li,all:bi,Cancel:Ji,isAxiosError:Hi,spread:Yi,toFormData:qi,AxiosHeaders:Mi,HttpStatusCode:Oi,formToJSON:Ti,getAdapter:Ki,mergeConfig:Pi}=PA;var uA,O,mt,yt={env:{emscripten_notify_memory_growth:function(A){mt=new Uint8Array(O.exports.memory.buffer)}}},xA=class{init(){return uA||(typeof fetch<"u"?uA=fetch("data:application/wasm;base64,"+de).then(t=>t.arrayBuffer()).then(t=>WebAssembly.instantiate(t,yt)).then(this._init):uA=WebAssembly.instantiate(Buffer.from(de,"base64"),yt).then(this._init),uA)}_init(t){O=t.instance,yt.env.emscripten_notify_memory_growth(0)}decode(t,e=0){if(!O)throw new Error("ZSTDDecoder: Await .init() before decoding.");let I=t.byteLength,r=O.exports.malloc(I);mt.set(t,r),e=e||Number(O.exports.ZSTD_findDecompressedSize(r,I));let o=O.exports.malloc(e),g=O.exports.ZSTD_decompress(o,e,r,I),s=mt.slice(o,o+g);return O.exports.free(r),O.exports.free(o),s}},de="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";var De=new xA,he=!1;async function Cr(A,t,e){let I=null;typeof A!="string"?I=A.href:A.startsWith("http")?I=A:I=`${t}/${A}`,I.endsWith(".js")&&(I=I.substring(0,I.length-3)),I.endsWith(".wasm")&&(I=I.substring(0,I.length-5)),I.endsWith(".wasm.zst")&&(I=I.substring(0,I.length-9));let r=`${I}.wasm`,o=await PA.get(`${r}.zst`,{responseType:"arraybuffer",params:e});he||(await De.init(),he=!0);let s=De.decode(new Uint8Array(o.data)).buffer;return(await import(`${I}.js`)).default({wasmBinary:s})}var ye=Cr;var jA=new Map;async function Br(A,t,e){let I=A,r=A,o=null;return typeof A!="string"&&(I=new URL(A.href),r=I.href),jA.has(r)?o=await jA.get(r):(jA.set(r,ye(I,t,e)),o=await jA.get(r)),o}var me=Br;var ar={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",PointSet:"PointSet",Mesh:"Mesh",PolyData:"PolyData",TransformList:"TransformList",JsonCompatible:"JsonCompatible"},d=ar;var Qr={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},k=Qr;var Er={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},V=Er;function cr(A,t){let e=null;switch(A){case k.UInt8:{e=new Uint8Array(t);break}case k.Int8:{e=new Int8Array(t);break}case k.UInt16:{e=new Uint16Array(t);break}case k.Int16:{e=new Int16Array(t);break}case k.UInt32:{e=new Uint32Array(t);break}case k.Int32:{e=new Int32Array(t);break}case k.UInt64:{typeof globalThis.BigUint64Array=="function"?e=new BigUint64Array(t):e=new Uint8Array(t);break}case k.Int64:{typeof globalThis.BigInt64Array=="function"?e=new BigInt64Array(t):e=new Uint8Array(t);break}case V.Float32:{e=new Float32Array(t);break}case V.Float64:{e=new Float64Array(t);break}case"null":{e=null;break}case null:{e=null;break}default:throw new Error("Type is not supported as a TypedArray")}return e}var M=cr;var Se=typeof globalThis.SharedArrayBuffer=="function",we=new TextEncoder,pe=new TextDecoder("utf-8");function fr(A,t){let e={flags:"r",encoding:"binary"},I=A.fs_open(t,e.flags),o=A.fs_stat(t).size,g=null;Se?g=new SharedArrayBuffer(o):g=new ArrayBuffer(o);let s=new Uint8Array(g);return A.fs_read(I,s,0,o,0),A.fs_close(I),s}function Fe(A,t,e){let I=null;Se?I=new SharedArrayBuffer(e):I=new ArrayBuffer(e);let r=new Uint8Array(I),o=new Uint8Array(A.HEAPU8.buffer,t,e);return r.set(o),r}function w(A,t,e,I){let r=0;return t!==null&&(r=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,e,I,t.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(t.buffer),r)),r}function x(A,t,e){let I=JSON.stringify(t),r=A.lengthBytesUTF8(I)+1,o=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,e,r]);A.stringToUTF8(I,o,r)}function S(A,t,e,I){let r=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,t,e]),o=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,t,e]),g=Fe(A,r,o);return M(I,g.buffer)}function dA(A,t){let e=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,t]),I=A.UTF8ToString(e);return JSON.parse(I)}function lr(A,t,e,I){I!=null&&I.length>0&&I.forEach(function(B,i){switch(B.type){case d.TextStream:{let C=we.encode(B.data.data),l=w(A,C,i,0),a={size:C.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};x(A,a,i);break}case d.JsonCompatible:{let C=we.encode(JSON.stringify(B.data)),l=w(A,C,i,0),a={size:C.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};x(A,a,i);break}case d.BinaryStream:{let C=B.data.data,l=w(A,C,i,0),a={size:C.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};x(A,a,i);break}case d.TextFile:{A.fs_writeFile(B.data.path,B.data.data);break}case d.BinaryFile:{A.fs_writeFile(B.data.path,B.data.data);break}case d.Image:{let C=B.data,l=w(A,C.data,i,0),a=w(A,C.direction,i,1),Q=typeof C.metadata?.entries<"u"?Array.from(C.metadata.entries()):[],f={imageType:C.imageType,name:C.name,origin:C.origin,spacing:C.spacing,direction:`data:application/vnd.itk.address,0:${a}`,size:C.size,data:`data:application/vnd.itk.address,0:${l}`,metadata:Q};x(A,f,i);break}case d.Mesh:{let C=B.data,l=w(A,C.points,i,0),a=w(A,C.cells,i,1),Q=w(A,C.pointData,i,2),f=w(A,C.cellData,i,3),c={meshType:C.meshType,name:C.name,numberOfPoints:C.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,numberOfCells:C.numberOfCells,cells:`data:application/vnd.itk.address,0:${a}`,cellBufferSize:C.cellBufferSize,numberOfPointPixels:C.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${Q}`,numberOfCellPixels:C.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${f}`};x(A,c,i);break}case d.PointSet:{let C=B.data,l=w(A,C.points,i,0),a=w(A,C.pointData,i,1),Q={pointSetType:C.pointSetType,name:C.name,numberOfPoints:C.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,numberOfPointPixels:C.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${a}`};x(A,Q,i);break}case d.TransformList:{let C=B.data,l=[],a=0;C.forEach(Q=>{let f="",c="";Q.transformType.transformParameterization!=="Composite"&&(f=`data:application/vnd.itk.address,0:${w(A,Q.fixedParameters,i,a)}`,a+=1,c=`data:application/vnd.itk.address,0:${w(A,Q.parameters,i,a)}`,a+=1);let D={transformType:Q.transformType,numberOfFixedParameters:Q.numberOfFixedParameters,numberOfParameters:Q.numberOfParameters,name:Q.name,inputSpaceName:Q.inputSpaceName,outputSpaceName:Q.outputSpaceName,parameters:c,fixedParameters:f};l.push(D)}),x(A,l,i);break}case d.PolyData:{let C=B.data,l=w(A,C.points,i,0),a=w(A,C.vertices,i,1),Q=w(A,C.lines,i,2),f=w(A,C.polygons,i,3),c=w(A,C.triangleStrips,i,4),D=w(A,C.pointData,i,5),F=w(A,C.pointData,i,6),y={polyDataType:C.polyDataType,name:C.name,numberOfPoints:C.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,verticesBufferSize:C.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${a}`,linesBufferSize:C.linesBufferSize,lines:`data:application/vnd.itk.address,0:${Q}`,polygonsBufferSize:C.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${f}`,triangleStripsBufferSize:C.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${c}`,numberOfPointPixels:C.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${D}`,numberOfCellPixels:C.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${F}`};x(A,y,i);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let r=A.stackSave(),o=0;try{o=A.callMain(t.slice())}catch(B){throw typeof B=="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(B)):console.error("Build module in Debug mode for exception message information.")),B}finally{A.stackRestore(r)}let g=A.getModuleStdout(),s=A.getModuleStderr(),E=[];return e!=null&&e.length>0&&o===0&&e.forEach(function(B,i){let C=null;switch(B.type){case d.TextStream:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]),f=new Uint8Array(A.HEAPU8.buffer,a,Q);C={data:pe.decode(f)};break}case d.JsonCompatible:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]),f=new Uint8Array(A.HEAPU8.buffer,a,Q);C=JSON.parse(pe.decode(f));break}case d.BinaryStream:{let a=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0]),Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]);C={data:Fe(A,a,Q)};break}case d.TextFile:{C={path:B.data.path,data:A.fs_readFile(B.data.path,{encoding:"utf8"})};break}case d.BinaryFile:{C={path:B.data.path,data:fr(A,B.data.path)};break}case d.Image:{let a=dA(A,i);a.data=S(A,i,0,a.imageType.componentType),a.direction=S(A,i,1,V.Float64),a.metadata=new Map(a.metadata),C=a;break}case d.Mesh:{let a=dA(A,i);a.numberOfPoints>0?a.points=S(A,i,0,a.meshType.pointComponentType):a.points=M(a.meshType.pointComponentType,new ArrayBuffer(0)),a.numberOfCells>0?a.cells=S(A,i,1,a.meshType.cellComponentType):a.cells=M(a.meshType.cellComponentType,new ArrayBuffer(0)),a.numberOfPointPixels>0?a.pointData=S(A,i,2,a.meshType.pointPixelComponentType):a.pointData=M(a.meshType.pointPixelComponentType,new ArrayBuffer(0)),a.numberOfCellPixels>0?a.cellData=S(A,i,3,a.meshType.cellPixelComponentType):a.cellData=M(a.meshType.cellPixelComponentType,new ArrayBuffer(0)),C=a;break}case d.PointSet:{let a=dA(A,i);a.numberOfPoints>0?a.points=S(A,i,0,a.pointSetType.pointComponentType):a.points=M(a.pointSetType.pointComponentType,new ArrayBuffer(0)),a.numberOfPointPixels>0?a.pointData=S(A,i,1,a.pointSetType.pointPixelComponentType):a.pointData=M(a.pointSetType.pointPixelComponentType,new ArrayBuffer(0)),C=a;break}case d.TransformList:{let a=dA(A,i),Q=0;a.forEach((f,c)=>{f.transformType.transformParameterization!=="Composite"&&(f.numberOfFixedParameters>0&&(a[c].fixedParameters=S(A,i,Q,V.Float64)),Q+=1,f.numberOfParameters>0&&(a[c].parameters=S(A,i,Q,f.transformType.parametersValueType)),Q+=1)}),C=a;break}case d.PolyData:{let a=dA(A,i);a.numberOfPoints>0?a.points=S(A,i,0,V.Float32):a.points=new Float32Array,a.verticesBufferSize>0?a.vertices=S(A,i,1,k.UInt32):a.vertices=new Uint32Array,a.linesBufferSize>0?a.lines=S(A,i,2,k.UInt32):a.lines=new Uint32Array,a.polygonsBufferSize>0?a.polygons=S(A,i,3,k.UInt32):a.polygons=new Uint32Array,a.triangleStripsBufferSize>0?a.triangleStrips=S(A,i,4,k.UInt32):a.triangleStrips=new Uint32Array,a.numberOfPointPixels>0?a.pointData=S(A,i,5,a.polyDataType.pointPixelComponentType):a.pointData=M(a.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),a.numberOfCellPixels>0?a.cellData=S(A,i,6,a.polyDataType.cellPixelComponentType):a.cellData=M(a.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),C=a;break}default:throw Error("Unsupported output InterfaceType")}let l={type:B.type,data:C};E.push(l)}),{returnValue:o,stdout:g,stderr:s,outputs:E}}var Re=lr;var ur=typeof globalThis.SharedArrayBuffer<"u";function dr(A,t){if(A==null)return[];let e=[];for(let I=0;I<A.length;I++){let r=Dr(A[I],t);r!==null&&e.push(r)}return e}function Dr(A,t){if(A==null)return null;let e=null;return A.buffer!==void 0?e=A.buffer:A.byteLength!==void 0&&(e=A),ur&&e instanceof SharedArrayBuffer?null:t?e:e.slice(0)}var Ne=dr;function hr(A){return[A.data,A.direction]}var Ue=hr;function yr(A){return[A.points,A.pointData,A.cells,A.cellData]}var Ge=yr;function mr(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var ke=mr;async function wr(A,t,e,I){let r=Re(A,t,e,I),o=[];return r.outputs.forEach(function(g){if(g.type===d.BinaryStream||g.type===d.BinaryFile){let s=g.data;o.push(s)}else if(g.type===d.Image){let s=g.data;o.push(...Ue(s))}else if(g.type===d.Mesh){let s=g.data;o.push(...Ge(s))}else if(g.type===d.PolyData){let s=g.data;o.push(...ke(s))}}),XA(r,Ne(o,!0))}var Le=wr;var pr={runPipeline:async function(A,t,e,I,r,o){let g=await me(A,t,o);return await Le(g,e,I,r)}};RA(pr);%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';zt(AI);export{oi as downsample,ei as downsampleBinShrink,Ii as downsampleLabelImage,ii as downsampleSigma,ai as gaussianKernelRadius,P as getDefaultWebWorker,J as getPipelineWorkerUrl,T as getPipelinesBaseUrl,qa as setDefaultWebWorker,zt as setPipelineWorkerUrl,Ga as setPipelinesBaseUrl,ee as version};
/*! Bundled license information:

comlink/dist/esm/comlink.mjs:
  (**
   * @license
   * Copyright 2019 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   *)
*/
"""
+default_js_module = """data:text/javascript;base64,var iI=Object.defineProperty;var oI=(A,e)=>{for(var t in e)iI(A,t,{get:e[t],enumerable:!0})};var gI="1.8.1",Ie=gI;var nI={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},N=nI;var aI={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},X=aI;function sI(A,e){let t=null;switch(A){case N.UInt8:{t=new Uint8Array(e);break}case N.Int8:{t=new Int8Array(e);break}case N.UInt16:{t=new Uint16Array(e);break}case N.Int16:{t=new Int16Array(e);break}case N.UInt32:{t=new Uint32Array(e);break}case N.Int32:{t=new Int32Array(e);break}case N.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case N.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case X.Float32:{t=new Float32Array(e);break}case X.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 P=sI;var CI={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",PointSet:"PointSet",Mesh:"Mesh",PolyData:"PolyData",TransformList:"TransformList",JsonCompatible:"JsonCompatible"},d=CI;var je=Symbol("Comlink.proxy"),BI=Symbol("Comlink.endpoint"),oe=Symbol("Comlink.releaseProxy"),re=Symbol("Comlink.finalizer"),bA=Symbol("Comlink.thrown"),ve=A=>typeof A=="object"&&A!==null||typeof A=="function",QI={canHandle:A=>ve(A)&&A[je],serialize(A){let{port1:e,port2:t}=new MessageChannel;return Ze(A,e),[t,[t]]},deserialize(A){return A.start(),ge(A)}},EI={canHandle:A=>ve(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}},_e=new Map([["proxy",QI],["throw",EI]]);function lI(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function Ze(A,e=globalThis,t=["*"]){e.addEventListener("message",function I(r){if(!r||!r.data)return;if(!lI(t,r.origin)){console.warn(`Invalid origin '${r.origin}' for comlink proxy`);return}let{id:i,type:o,path:a}=Object.assign({path:[]},r.data),Q=(r.data.argumentList||[]).map(z),C;try{let g=a.slice(0,-1).reduce((f,B)=>f[B],A),s=a.reduce((f,B)=>f[B],A);switch(o){case"GET":C=s;break;case"SET":g[a.slice(-1)[0]]=z(r.data.value),C=!0;break;case"APPLY":C=s.apply(g,Q);break;case"CONSTRUCT":{let f=new s(...Q);C=pI(f)}break;case"ENDPOINT":{let{port1:f,port2:B}=new MessageChannel;Ze(A,B),C=ne(f,[f])}break;case"RELEASE":C=void 0;break;default:return}}catch(g){C={value:g,[bA]:0}}Promise.resolve(C).catch(g=>({value:g,[bA]:0})).then(g=>{let[s,f]=MA(g);e.postMessage(Object.assign(Object.assign({},s),{id:i}),f),o==="RELEASE"&&(e.removeEventListener("message",I),Ve(e),re in A&&typeof A[re]=="function"&&A[re]())}).catch(g=>{let[s,f]=MA({value:new TypeError("Unserializable return value"),[bA]:0});e.postMessage(Object.assign(Object.assign({},s),{id:i}),f)})}),e.start&&e.start()}function cI(A){return A.constructor.name==="MessagePort"}function Ve(A){cI(A)&&A.close()}function ge(A,e){return ie(A,[],e)}function GA(A){if(A)throw new Error("Proxy has been released and is not useable")}function Xe(A){return eA(A,{type:"RELEASE"}).then(()=>{Ve(A)})}var LA=new WeakMap,JA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(LA.get(A)||0)-1;LA.set(A,e),e===0&&Xe(A)});function fI(A,e){let t=(LA.get(e)||0)+1;LA.set(e,t),JA&&JA.register(A,e,A)}function uI(A){JA&&JA.unregister(A)}function ie(A,e=[],t=function(){}){let I=!1,r=new Proxy(t,{get(i,o){if(GA(I),o===oe)return()=>{uI(r),Xe(A),I=!0};if(o==="then"){if(e.length===0)return{then:()=>r};let a=eA(A,{type:"GET",path:e.map(Q=>Q.toString())}).then(z);return a.then.bind(a)}return ie(A,[...e,o])},set(i,o,a){GA(I);let[Q,C]=MA(a);return eA(A,{type:"SET",path:[...e,o].map(g=>g.toString()),value:Q},C).then(z)},apply(i,o,a){GA(I);let Q=e[e.length-1];if(Q===BI)return eA(A,{type:"ENDPOINT"}).then(z);if(Q==="bind")return ie(A,e.slice(0,-1));let[C,g]=We(a);return eA(A,{type:"APPLY",path:e.map(s=>s.toString()),argumentList:C},g).then(z)},construct(i,o){GA(I);let[a,Q]=We(o);return eA(A,{type:"CONSTRUCT",path:e.map(C=>C.toString()),argumentList:a},Q).then(z)}});return fI(r,A),r}function dI(A){return Array.prototype.concat.apply([],A)}function We(A){let e=A.map(MA);return[e.map(t=>t[0]),dI(e.map(t=>t[1]))]}var ze=new WeakMap;function ne(A,e){return ze.set(A,e),A}function pI(A){return Object.assign(A,{[je]:!0})}function MA(A){for(let[e,t]of _e)if(t.canHandle(A)){let[I,r]=t.serialize(A);return[{type:"HANDLER",name:e,value:I},r]}return[{type:"RAW",value:A},ze.get(A)||[]]}function z(A){switch(A.type){case"HANDLER":return _e.get(A.name).deserialize(A.value);case"RAW":return A.value}}function eA(A,e,t){return new Promise(I=>{let r=hI();A.addEventListener("message",function i(o){!o.data||!o.data.id||o.data.id!==r||(A.removeEventListener("message",i),I(o.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:r},e),t)})}function hI(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function EA(A,e){return function(){return A.apply(e,arguments)}}var{toString:DI}=Object.prototype,{getPrototypeOf:YA}=Object,{iterator:OA,toStringTag:It}=Symbol,qA=(A=>e=>{let t=DI.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),T=A=>(A=A.toLowerCase(),e=>qA(e)===A),TA=A=>e=>typeof e===A,{isArray:IA}=Array,tA=TA("undefined");function lA(A){return A!==null&&!tA(A)&&A.constructor!==null&&!tA(A.constructor)&&G(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var rt=T("ArrayBuffer");function yI(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&rt(A.buffer),e}var wI=TA("string"),G=TA("function"),it=TA("number"),cA=A=>A!==null&&typeof A=="object",mI=A=>A===!0||A===!1,HA=A=>{if(qA(A)!=="object")return!1;let e=YA(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!(It in A)&&!(OA in A)},SI=A=>{if(!cA(A)||lA(A))return!1;try{return Object.keys(A).length===0&&Object.getPrototypeOf(A)===Object.prototype}catch{return!1}},RI=T("Date"),FI=T("File"),kI=A=>!!(A&&typeof A.uri<"u"),UI=A=>A&&typeof A.getParts<"u",NI=T("Blob"),GI=T("FileList"),bI=A=>cA(A)&&G(A.pipe);function LI(){return typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{}}var At=LI(),et=typeof At.FormData<"u"?At.FormData:void 0,JI=A=>{if(!A)return!1;if(et&&A instanceof et)return!0;let e=YA(A);if(!e||e===Object.prototype||!G(A.append))return!1;let t=qA(A);return t==="formdata"||t==="object"&&G(A.toString)&&A.toString()==="[object FormData]"},MI=T("URLSearchParams"),[HI,YI,OI,qI]=["ReadableStream","Request","Response","Headers"].map(T),TI=A=>A.trim?A.trim():A.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function fA(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let I,r;if(typeof A!="object"&&(A=[A]),IA(A))for(I=0,r=A.length;I<r;I++)e.call(null,A[I],I,A);else{if(lA(A))return;let i=t?Object.getOwnPropertyNames(A):Object.keys(A),o=i.length,a;for(I=0;I<o;I++)a=i[I],e.call(null,A[a],a,A)}}function ot(A,e){if(lA(A))return null;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 $=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,gt=A=>!tA(A)&&A!==$;function ae(){let{caseless:A,skipUndefined:e}=gt(this)&&this||{},t={},I=(r,i)=>{if(i==="__proto__"||i==="constructor"||i==="prototype")return;let o=A&&ot(t,i)||i;HA(t[o])&&HA(r)?t[o]=ae(t[o],r):HA(r)?t[o]=ae({},r):IA(r)?t[o]=r.slice():(!e||!tA(r))&&(t[o]=r)};for(let r=0,i=arguments.length;r<i;r++)arguments[r]&&fA(arguments[r],I);return t}var KI=(A,e,t,{allOwnKeys:I}={})=>(fA(e,(r,i)=>{t&&G(r)?Object.defineProperty(A,i,{value:EA(r,t),writable:!0,enumerable:!0,configurable:!0}):Object.defineProperty(A,i,{value:r,writable:!0,enumerable:!0,configurable:!0})},{allOwnKeys:I}),A),PI=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),xI=(A,e,t,I)=>{A.prototype=Object.create(e.prototype,I),Object.defineProperty(A.prototype,"constructor",{value:A,writable:!0,enumerable:!1,configurable:!0}),Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},WI=(A,e,t,I)=>{let r,i,o,a={};if(e=e||{},A==null)return e;do{for(r=Object.getOwnPropertyNames(A),i=r.length;i-- >0;)o=r[i],(!I||I(o,A,e))&&!a[o]&&(e[o]=A[o],a[o]=!0);A=t!==!1&&YA(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},jI=(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},vI=A=>{if(!A)return null;if(IA(A))return A;let e=A.length;if(!it(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},_I=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&YA(Uint8Array)),ZI=(A,e)=>{let I=(A&&A[OA]).call(A),r;for(;(r=I.next())&&!r.done;){let i=r.value;e.call(A,i[0],i[1])}},VI=(A,e)=>{let t,I=[];for(;(t=A.exec(e))!==null;)I.push(t);return I},XI=T("HTMLFormElement"),zI=A=>A.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(t,I,r){return I.toUpperCase()+r}),tt=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),$I=T("RegExp"),nt=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),I={};fA(t,(r,i)=>{let o;(o=e(r,i,A))!==!1&&(I[i]=o||r)}),Object.defineProperties(A,I)},Ar=A=>{nt(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+"'")})}})},er=(A,e)=>{let t={},I=r=>{r.forEach(i=>{t[i]=!0})};return IA(A)?I(A):I(String(A).split(e)),t},tr=()=>{},Ir=(A,e)=>A!=null&&Number.isFinite(A=+A)?A:e;function rr(A){return!!(A&&G(A.append)&&A[It]==="FormData"&&A[OA])}var ir=A=>{let e=new Array(10),t=(I,r)=>{if(cA(I)){if(e.indexOf(I)>=0)return;if(lA(I))return I;if(!("toJSON"in I)){e[r]=I;let i=IA(I)?[]:{};return fA(I,(o,a)=>{let Q=t(o,r+1);!tA(Q)&&(i[a]=Q)}),e[r]=void 0,i}}return I};return t(A,0)},or=T("AsyncFunction"),gr=A=>A&&(cA(A)||G(A))&&G(A.then)&&G(A.catch),at=((A,e)=>A?setImmediate:e?((t,I)=>($.addEventListener("message",({source:r,data:i})=>{r===$&&i===t&&I.length&&I.shift()()},!1),r=>{I.push(r),$.postMessage(t,"*")}))(`axios@${Math.random()}`,[]):t=>setTimeout(t))(typeof setImmediate=="function",G($.postMessage)),nr=typeof queueMicrotask<"u"?queueMicrotask.bind($):typeof process<"u"&&process.nextTick||at,ar=A=>A!=null&&G(A[OA]),n={isArray:IA,isArrayBuffer:rt,isBuffer:lA,isFormData:JI,isArrayBufferView:yI,isString:wI,isNumber:it,isBoolean:mI,isObject:cA,isPlainObject:HA,isEmptyObject:SI,isReadableStream:HI,isRequest:YI,isResponse:OI,isHeaders:qI,isUndefined:tA,isDate:RI,isFile:FI,isReactNativeBlob:kI,isReactNative:UI,isBlob:NI,isRegExp:$I,isFunction:G,isStream:bI,isURLSearchParams:MI,isTypedArray:_I,isFileList:GI,forEach:fA,merge:ae,extend:KI,trim:TI,stripBOM:PI,inherits:xI,toFlatObject:WI,kindOf:qA,kindOfTest:T,endsWith:jI,toArray:vI,forEachEntry:ZI,matchAll:VI,isHTMLForm:XI,hasOwnProperty:tt,hasOwnProp:tt,reduceDescriptors:nt,freezeMethods:Ar,toObjectSet:er,toCamelCase:zI,noop:tr,toFiniteNumber:Ir,findKey:ot,global:$,isContextDefined:gt,isSpecCompliantForm:rr,toJSONObject:ir,isAsyncFn:or,isThenable:gr,setImmediate:at,asap:nr,isIterable:ar};var F=class A extends Error{static from(e,t,I,r,i,o){let a=new A(e.message,t||e.code,I,r,i);return a.cause=e,a.name=e.name,e.status!=null&&a.status==null&&(a.status=e.status),o&&Object.assign(a,o),a}constructor(e,t,I,r,i){super(e),Object.defineProperty(this,"message",{value:e,enumerable:!0,writable:!0,configurable:!0}),this.name="AxiosError",this.isAxiosError=!0,t&&(this.code=t),I&&(this.config=I),r&&(this.request=r),i&&(this.response=i,this.status=i.status)}toJSON(){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:n.toJSONObject(this.config),code:this.code,status:this.status}}};F.ERR_BAD_OPTION_VALUE="ERR_BAD_OPTION_VALUE";F.ERR_BAD_OPTION="ERR_BAD_OPTION";F.ECONNABORTED="ECONNABORTED";F.ETIMEDOUT="ETIMEDOUT";F.ERR_NETWORK="ERR_NETWORK";F.ERR_FR_TOO_MANY_REDIRECTS="ERR_FR_TOO_MANY_REDIRECTS";F.ERR_DEPRECATED="ERR_DEPRECATED";F.ERR_BAD_RESPONSE="ERR_BAD_RESPONSE";F.ERR_BAD_REQUEST="ERR_BAD_REQUEST";F.ERR_CANCELED="ERR_CANCELED";F.ERR_NOT_SUPPORT="ERR_NOT_SUPPORT";F.ERR_INVALID_URL="ERR_INVALID_URL";F.ERR_FORM_DATA_DEPTH_EXCEEDED="ERR_FORM_DATA_DEPTH_EXCEEDED";var u=F;var KA=null;function Ce(A){return n.isPlainObject(A)||n.isArray(A)}function st(A){return n.endsWith(A,"[]")?A.slice(0,-2):A}function se(A,e,t){return A?A.concat(e).map(function(r,i){return r=st(r),!t&&i?"["+r+"]":r}).join(t?".":""):e}function sr(A){return n.isArray(A)&&!A.some(Ce)}var Cr=n.toFlatObject(n,{},null,function(e){return/^is[A-Z]/.test(e)});function Br(A,e,t){if(!n.isObject(A))throw new TypeError("target must be an object");e=e||new(KA||FormData),t=n.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(E,p){return!n.isUndefined(p[E])});let I=t.metaTokens,r=t.visitor||s,i=t.dots,o=t.indexes,a=t.Blob||typeof Blob<"u"&&Blob,Q=t.maxDepth===void 0?100:t.maxDepth,C=a&&n.isSpecCompliantForm(e);if(!n.isFunction(r))throw new TypeError("visitor must be a function");function g(c){if(c===null)return"";if(n.isDate(c))return c.toISOString();if(n.isBoolean(c))return c.toString();if(!C&&n.isBlob(c))throw new u("Blob is not supported. Use a Buffer instead.");return n.isArrayBuffer(c)||n.isTypedArray(c)?C&&typeof Blob=="function"?new Blob([c]):Buffer.from(c):c}function s(c,E,p){let J=c;if(n.isReactNative(e)&&n.isReactNativeBlob(c))return e.append(se(p,E,i),g(c)),!1;if(c&&!p&&typeof c=="object"){if(n.endsWith(E,"{}"))E=I?E:E.slice(0,-2),c=JSON.stringify(c);else if(n.isArray(c)&&sr(c)||(n.isFileList(c)||n.endsWith(E,"[]"))&&(J=n.toArray(c)))return E=st(E),J.forEach(function(y,k){!(n.isUndefined(y)||y===null)&&e.append(o===!0?se([E],k,i):o===null?E:E+"[]",g(y))}),!1}return Ce(c)?!0:(e.append(se(p,E,i),g(c)),!1)}let f=[],B=Object.assign(Cr,{defaultVisitor:s,convertValue:g,isVisitable:Ce});function l(c,E,p=0){if(!n.isUndefined(c)){if(p>Q)throw new u("Object is too deeply nested ("+p+" levels). Max depth: "+Q,u.ERR_FORM_DATA_DEPTH_EXCEEDED);if(f.indexOf(c)!==-1)throw Error("Circular reference detected in "+E.join("."));f.push(c),n.forEach(c,function(D,y){(!(n.isUndefined(D)||D===null)&&r.call(e,D,n.isString(y)?y.trim():y,E,B))===!0&&l(D,E?E.concat(y):[y],p+1)}),f.pop()}}if(!n.isObject(A))throw new TypeError("data must be an object");return l(A),e}var v=Br;function Ct(A){let e={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+"};return encodeURIComponent(A).replace(/[!'()~]|%20/g,function(I){return e[I]})}function Bt(A,e){this._pairs=[],A&&v(A,this,e)}var Qt=Bt.prototype;Qt.append=function(e,t){this._pairs.push([e,t])};Qt.toString=function(e){let t=e?function(I){return e.call(this,I,Ct)}:Ct;return this._pairs.map(function(r){return t(r[0])+"="+t(r[1])},"").join("&")};var PA=Bt;function Qr(A){return encodeURIComponent(A).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+")}function uA(A,e,t){if(!e)return A;let I=t&&t.encode||Qr,r=n.isFunction(t)?{serialize:t}:t,i=r&&r.serialize,o;if(i?o=i(e,r):o=n.isURLSearchParams(e)?e.toString():new PA(e,r).toString(I),o){let a=A.indexOf("#");a!==-1&&(A=A.slice(0,a)),A+=(A.indexOf("?")===-1?"?":"&")+o}return A}var Be=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){n.forEach(this.handlers,function(I){I!==null&&e(I)})}},Qe=Be;var rA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1,legacyInterceptorReqResOrdering:!0};var Et=typeof URLSearchParams<"u"?URLSearchParams:PA;var lt=typeof FormData<"u"?FormData:null;var ct=typeof Blob<"u"?Blob:null;var ft={isBrowser:!0,classes:{URLSearchParams:Et,FormData:lt,Blob:ct},protocols:["http","https","file","blob","url","data"]};var ce={};oI(ce,{hasBrowserEnv:()=>le,hasStandardBrowserEnv:()=>Er,hasStandardBrowserWebWorkerEnv:()=>lr,navigator:()=>Ee,origin:()=>cr});var le=typeof window<"u"&&typeof document<"u",Ee=typeof navigator=="object"&&navigator||void 0,Er=le&&(!Ee||["ReactNative","NativeScript","NS"].indexOf(Ee.product)<0),lr=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function",cr=le&&window.location.href||"http://localhost";var h={...ce,...ft};function fe(A,e){return v(A,new h.classes.URLSearchParams,{visitor:function(t,I,r,i){return h.isNode&&n.isBuffer(t)?(this.append(I,t.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)},...e})}function fr(A){return n.matchAll(/\w+|\[(\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function ur(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 dr(A){function e(t,I,r,i){let o=t[i++];if(o==="__proto__")return!0;let a=Number.isFinite(+o),Q=i>=t.length;return o=!o&&n.isArray(r)?r.length:o,Q?(n.hasOwnProp(r,o)?r[o]=n.isArray(r[o])?r[o].concat(I):[r[o],I]:r[o]=I,!a):((!r[o]||!n.isObject(r[o]))&&(r[o]=[]),e(t,I,r[o],i)&&n.isArray(r[o])&&(r[o]=ur(r[o])),!a)}if(n.isFormData(A)&&n.isFunction(A.entries)){let t={};return n.forEachEntry(A,(I,r)=>{e(fr(I),r,t,0)}),t}return null}var xA=dr;var iA=(A,e)=>A!=null&&n.hasOwnProp(A,e)?A[e]:void 0;function pr(A,e,t){if(n.isString(A))try{return(e||JSON.parse)(A),n.trim(A)}catch(I){if(I.name!=="SyntaxError")throw I}return(t||JSON.stringify)(A)}var ue={transitional:rA,adapter:["xhr","http","fetch"],transformRequest:[function(e,t){let I=t.getContentType()||"",r=I.indexOf("application/json")>-1,i=n.isObject(e);if(i&&n.isHTMLForm(e)&&(e=new FormData(e)),n.isFormData(e))return r?JSON.stringify(xA(e)):e;if(n.isArrayBuffer(e)||n.isBuffer(e)||n.isStream(e)||n.isFile(e)||n.isBlob(e)||n.isReadableStream(e))return e;if(n.isArrayBufferView(e))return e.buffer;if(n.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let a;if(i){let Q=iA(this,"formSerializer");if(I.indexOf("application/x-www-form-urlencoded")>-1)return fe(e,Q).toString();if((a=n.isFileList(e))||I.indexOf("multipart/form-data")>-1){let C=iA(this,"env"),g=C&&C.FormData;return v(a?{"files[]":e}:e,g&&new g,Q)}}return i||r?(t.setContentType("application/json",!1),pr(e)):e}],transformResponse:[function(e){let t=iA(this,"transitional")||ue.transitional,I=t&&t.forcedJSONParsing,r=iA(this,"responseType"),i=r==="json";if(n.isResponse(e)||n.isReadableStream(e))return e;if(e&&n.isString(e)&&(I&&!r||i)){let a=!(t&&t.silentJSONParsing)&&i;try{return JSON.parse(e,iA(this,"parseReviver"))}catch(Q){if(a)throw Q.name==="SyntaxError"?u.from(Q,u.ERR_BAD_RESPONSE,this,null,iA(this,"response")):Q}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:h.classes.FormData,Blob:h.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};n.forEach(["delete","get","head","post","put","patch"],A=>{ue.headers[A]={}});var oA=ue;var hr=n.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"]),ut=A=>{let e={},t,I,r;return A&&A.split(`
`).forEach(function(o){r=o.indexOf(":"),t=o.substring(0,r).trim().toLowerCase(),I=o.substring(r+1).trim(),!(!t||e[t]&&hr[t])&&(t==="set-cookie"?e[t]?e[t].push(I):e[t]=[I]:e[t]=e[t]?e[t]+", "+I:I)}),e};var dt=Symbol("internals"),Dr=/[^\x09\x20-\x7E\x80-\xFF]/g;function yr(A){let e=0,t=A.length;for(;e<t;){let I=A.charCodeAt(e);if(I!==9&&I!==32)break;e+=1}for(;t>e;){let I=A.charCodeAt(t-1);if(I!==9&&I!==32)break;t-=1}return e===0&&t===A.length?A:A.slice(e,t)}function dA(A){return A&&String(A).trim().toLowerCase()}function wr(A){return yr(A.replace(Dr,""))}function WA(A){return A===!1||A==null?A:n.isArray(A)?A.map(WA):wr(String(A))}function mr(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 Sr=A=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(A.trim());function de(A,e,t,I,r){if(n.isFunction(I))return I.call(this,e,t);if(r&&(e=t),!!n.isString(e)){if(n.isString(I))return e.indexOf(I)!==-1;if(n.isRegExp(I))return I.test(e)}}function Rr(A){return A.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(e,t,I)=>t.toUpperCase()+I)}function Fr(A,e){let t=n.toCamelCase(" "+e);["get","set","has"].forEach(I=>{Object.defineProperty(A,I+t,{value:function(r,i,o){return this[I].call(this,e,r,i,o)},configurable:!0})})}var gA=class{constructor(e){e&&this.set(e)}set(e,t,I){let r=this;function i(a,Q,C){let g=dA(Q);if(!g)throw new Error("header name must be a non-empty string");let s=n.findKey(r,g);(!s||r[s]===void 0||C===!0||C===void 0&&r[s]!==!1)&&(r[s||Q]=WA(a))}let o=(a,Q)=>n.forEach(a,(C,g)=>i(C,g,Q));if(n.isPlainObject(e)||e instanceof this.constructor)o(e,t);else if(n.isString(e)&&(e=e.trim())&&!Sr(e))o(ut(e),t);else if(n.isObject(e)&&n.isIterable(e)){let a={},Q,C;for(let g of e){if(!n.isArray(g))throw TypeError("Object iterator must return a key-value pair");a[C=g[0]]=(Q=a[C])?n.isArray(Q)?[...Q,g[1]]:[Q,g[1]]:g[1]}o(a,t)}else e!=null&&i(t,e,I);return this}get(e,t){if(e=dA(e),e){let I=n.findKey(this,e);if(I){let r=this[I];if(!t)return r;if(t===!0)return mr(r);if(n.isFunction(t))return t.call(this,r,I);if(n.isRegExp(t))return t.exec(r);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=dA(e),e){let I=n.findKey(this,e);return!!(I&&this[I]!==void 0&&(!t||de(this,this[I],I,t)))}return!1}delete(e,t){let I=this,r=!1;function i(o){if(o=dA(o),o){let a=n.findKey(I,o);a&&(!t||de(I,I[a],a,t))&&(delete I[a],r=!0)}}return n.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||de(this,this[i],i,e,!0))&&(delete this[i],r=!0)}return r}normalize(e){let t=this,I={};return n.forEach(this,(r,i)=>{let o=n.findKey(I,i);if(o){t[o]=WA(r),delete t[i];return}let a=e?Rr(i):String(i).trim();a!==i&&delete t[i],t[a]=WA(r),I[a]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return n.forEach(this,(I,r)=>{I!=null&&I!==!1&&(t[r]=e&&n.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(`
`)}getSetCookie(){return this.get("set-cookie")||[]}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[dt]=this[dt]={accessors:{}}).accessors,r=this.prototype;function i(o){let a=dA(o);I[a]||(Fr(r,o),I[a]=!0)}return n.isArray(e)?e.forEach(i):i(e),this}};gA.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);n.reduceDescriptors(gA.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(I){this[t]=I}}});n.freezeMethods(gA);var S=gA;function pA(A,e){let t=this||oA,I=e||t,r=S.from(I.headers),i=I.data;return n.forEach(A,function(a){i=a.call(t,i,r.normalize(),e?e.status:void 0)}),r.normalize(),i}function hA(A){return!!(A&&A.__CANCEL__)}var pe=class extends u{constructor(e,t,I){super(e??"canceled",u.ERR_CANCELED,t,I),this.name="CanceledError",this.__CANCEL__=!0}},x=pe;function DA(A,e,t){let I=t.config.validateStatus;!t.status||!I||I(t.status)?A(t):e(new u("Request failed with status code "+t.status,[u.ERR_BAD_REQUEST,u.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}function he(A){let e=/^([-+\w]{1,25})(:?\/\/|:)/.exec(A);return e&&e[1]||""}function kr(A,e){A=A||10;let t=new Array(A),I=new Array(A),r=0,i=0,o;return e=e!==void 0?e:1e3,function(Q){let C=Date.now(),g=I[i];o||(o=C),t[r]=Q,I[r]=C;let s=i,f=0;for(;s!==r;)f+=t[s++],s=s%A;if(r=(r+1)%A,r===i&&(i=(i+1)%A),C-o<e)return;let B=g&&C-g;return B?Math.round(f*1e3/B):void 0}}var pt=kr;function Ur(A,e){let t=0,I=1e3/e,r,i,o=(C,g=Date.now())=>{t=g,r=null,i&&(clearTimeout(i),i=null),A(...C)};return[(...C)=>{let g=Date.now(),s=g-t;s>=I?o(C,g):(r=C,i||(i=setTimeout(()=>{i=null,o(r)},I-s)))},()=>r&&o(r)]}var ht=Ur;var nA=(A,e,t=3)=>{let I=0,r=pt(50,250);return ht(i=>{let o=i.loaded,a=i.lengthComputable?i.total:void 0,Q=a!=null?Math.min(o,a):o,C=Math.max(0,Q-I),g=r(C);I=Math.max(I,Q);let s={loaded:Q,total:a,progress:a?Q/a:void 0,bytes:C,rate:g||void 0,estimated:g&&a?(a-Q)/g:void 0,event:i,lengthComputable:a!=null,[e?"download":"upload"]:!0};A(s)},t)},De=(A,e)=>{let t=A!=null;return[I=>e[0]({lengthComputable:t,total:A,loaded:I}),e[1]]},ye=A=>(...e)=>n.asap(()=>A(...e));var Dt=h.hasStandardBrowserEnv?((A,e)=>t=>(t=new URL(t,h.origin),A.protocol===t.protocol&&A.host===t.host&&(e||A.port===t.port)))(new URL(h.origin),h.navigator&&/(msie|trident)/i.test(h.navigator.userAgent)):()=>!0;var yt=h.hasStandardBrowserEnv?{write(A,e,t,I,r,i,o){if(typeof document>"u")return;let a=[`${A}=${encodeURIComponent(e)}`];n.isNumber(t)&&a.push(`expires=${new Date(t).toUTCString()}`),n.isString(I)&&a.push(`path=${I}`),n.isString(r)&&a.push(`domain=${r}`),i===!0&&a.push("secure"),n.isString(o)&&a.push(`SameSite=${o}`),document.cookie=a.join("; ")},read(A){if(typeof document>"u")return null;let e=document.cookie.match(new RegExp("(?:^|; )"+A+"=([^;]*)"));return e?decodeURIComponent(e[1]):null},remove(A){this.write(A,"",Date.now()-864e5,"/")}}:{write(){},read(){return null},remove(){}};function we(A){return typeof A!="string"?!1:/^([a-z][a-z\d+\-.]*:)?\/\//i.test(A)}function me(A,e){return e?A.replace(/\/?\/$/,"")+"/"+e.replace(/^\/+/,""):A}function yA(A,e,t){let I=!we(e);return A&&(I||t===!1)?me(A,e):e}var wt=A=>A instanceof S?{...A}:A;function K(A,e){e=e||{};let t=Object.create(null);Object.defineProperty(t,"hasOwnProperty",{value:Object.prototype.hasOwnProperty,enumerable:!1,writable:!0,configurable:!0});function I(C,g,s,f){return n.isPlainObject(C)&&n.isPlainObject(g)?n.merge.call({caseless:f},C,g):n.isPlainObject(g)?n.merge({},g):n.isArray(g)?g.slice():g}function r(C,g,s,f){if(n.isUndefined(g)){if(!n.isUndefined(C))return I(void 0,C,s,f)}else return I(C,g,s,f)}function i(C,g){if(!n.isUndefined(g))return I(void 0,g)}function o(C,g){if(n.isUndefined(g)){if(!n.isUndefined(C))return I(void 0,C)}else return I(void 0,g)}function a(C,g,s){if(n.hasOwnProp(e,s))return I(C,g);if(n.hasOwnProp(A,s))return I(void 0,C)}let Q={url:i,method:i,data:i,baseURL:o,transformRequest:o,transformResponse:o,paramsSerializer:o,timeout:o,timeoutMessage:o,withCredentials:o,withXSRFToken:o,adapter:o,responseType:o,xsrfCookieName:o,xsrfHeaderName:o,onUploadProgress:o,onDownloadProgress:o,decompress:o,maxContentLength:o,maxBodyLength:o,beforeRedirect:o,transport:o,httpAgent:o,httpsAgent:o,cancelToken:o,socketPath:o,allowedSocketPaths:o,responseEncoding:o,validateStatus:a,headers:(C,g,s)=>r(wt(C),wt(g),s,!0)};return n.forEach(Object.keys({...A,...e}),function(g){if(g==="__proto__"||g==="constructor"||g==="prototype")return;let s=n.hasOwnProp(Q,g)?Q[g]:r,f=n.hasOwnProp(A,g)?A[g]:void 0,B=n.hasOwnProp(e,g)?e[g]:void 0,l=s(f,B,g);n.isUndefined(l)&&s!==a||(t[g]=l)}),t}var jA=A=>{let e=K({},A),t=f=>n.hasOwnProp(e,f)?e[f]:void 0,I=t("data"),r=t("withXSRFToken"),i=t("xsrfHeaderName"),o=t("xsrfCookieName"),a=t("headers"),Q=t("auth"),C=t("baseURL"),g=t("allowAbsoluteUrls"),s=t("url");if(e.headers=a=S.from(a),e.url=uA(yA(C,s,g),A.params,A.paramsSerializer),Q&&a.set("Authorization","Basic "+btoa((Q.username||"")+":"+(Q.password?unescape(encodeURIComponent(Q.password)):""))),n.isFormData(I)){if(h.hasStandardBrowserEnv||h.hasStandardBrowserWebWorkerEnv)a.setContentType(void 0);else if(n.isFunction(I.getHeaders)){let f=I.getHeaders(),B=["content-type","content-length"];Object.entries(f).forEach(([l,c])=>{B.includes(l.toLowerCase())&&a.set(l,c)})}}if(h.hasStandardBrowserEnv&&(n.isFunction(r)&&(r=r(e)),r===!0||r==null&&Dt(e.url))){let B=i&&o&&yt.read(o);B&&a.set(i,B)}return e};var Nr=typeof XMLHttpRequest<"u",mt=Nr&&function(A){return new Promise(function(t,I){let r=jA(A),i=r.data,o=S.from(r.headers).normalize(),{responseType:a,onUploadProgress:Q,onDownloadProgress:C}=r,g,s,f,B,l;function c(){B&&B(),l&&l(),r.cancelToken&&r.cancelToken.unsubscribe(g),r.signal&&r.signal.removeEventListener("abort",g)}let E=new XMLHttpRequest;E.open(r.method.toUpperCase(),r.url,!0),E.timeout=r.timeout;function p(){if(!E)return;let D=S.from("getAllResponseHeaders"in E&&E.getAllResponseHeaders()),k={data:!a||a==="text"||a==="json"?E.responseText:E.response,status:E.status,statusText:E.statusText,headers:D,config:A,request:E};DA(function(M){t(M),c()},function(M){I(M),c()},k),E=null}"onloadend"in E?E.onloadend=p:E.onreadystatechange=function(){!E||E.readyState!==4||E.status===0&&!(E.responseURL&&E.responseURL.indexOf("file:")===0)||setTimeout(p)},E.onabort=function(){E&&(I(new u("Request aborted",u.ECONNABORTED,A,E)),E=null)},E.onerror=function(y){let k=y&&y.message?y.message:"Network Error",Z=new u(k,u.ERR_NETWORK,A,E);Z.event=y||null,I(Z),E=null},E.ontimeout=function(){let y=r.timeout?"timeout of "+r.timeout+"ms exceeded":"timeout exceeded",k=r.transitional||rA;r.timeoutErrorMessage&&(y=r.timeoutErrorMessage),I(new u(y,k.clarifyTimeoutError?u.ETIMEDOUT:u.ECONNABORTED,A,E)),E=null},i===void 0&&o.setContentType(null),"setRequestHeader"in E&&n.forEach(o.toJSON(),function(y,k){E.setRequestHeader(k,y)}),n.isUndefined(r.withCredentials)||(E.withCredentials=!!r.withCredentials),a&&a!=="json"&&(E.responseType=r.responseType),C&&([f,l]=nA(C,!0),E.addEventListener("progress",f)),Q&&E.upload&&([s,B]=nA(Q),E.upload.addEventListener("progress",s),E.upload.addEventListener("loadend",B)),(r.cancelToken||r.signal)&&(g=D=>{E&&(I(!D||D.type?new x(null,A,E):D),E.abort(),E=null)},r.cancelToken&&r.cancelToken.subscribe(g),r.signal&&(r.signal.aborted?g():r.signal.addEventListener("abort",g)));let J=he(r.url);if(J&&h.protocols.indexOf(J)===-1){I(new u("Unsupported protocol "+J+":",u.ERR_BAD_REQUEST,A));return}E.send(i||null)})};var Gr=(A,e)=>{let{length:t}=A=A?A.filter(Boolean):[];if(e||t){let I=new AbortController,r,i=function(C){if(!r){r=!0,a();let g=C instanceof Error?C:this.reason;I.abort(g instanceof u?g:new x(g instanceof Error?g.message:g))}},o=e&&setTimeout(()=>{o=null,i(new u(`timeout of ${e}ms exceeded`,u.ETIMEDOUT))},e),a=()=>{A&&(o&&clearTimeout(o),o=null,A.forEach(C=>{C.unsubscribe?C.unsubscribe(i):C.removeEventListener("abort",i)}),A=null)};A.forEach(C=>C.addEventListener("abort",i));let{signal:Q}=I;return Q.unsubscribe=()=>n.asap(a),Q}},St=Gr;var br=function*(A,e){let t=A.byteLength;if(!e||t<e){yield A;return}let I=0,r;for(;I<t;)r=I+e,yield A.slice(I,r),I=r},Lr=async function*(A,e){for await(let t of Jr(A))yield*br(t,e)},Jr=async function*(A){if(A[Symbol.asyncIterator]){yield*A;return}let e=A.getReader();try{for(;;){let{done:t,value:I}=await e.read();if(t)break;yield I}}finally{await e.cancel()}},Se=(A,e,t,I)=>{let r=Lr(A,e),i=0,o,a=Q=>{o||(o=!0,I&&I(Q))};return new ReadableStream({async pull(Q){try{let{done:C,value:g}=await r.next();if(C){a(),Q.close();return}let s=g.byteLength;if(t){let f=i+=s;t(f)}Q.enqueue(new Uint8Array(g))}catch(C){throw a(C),C}},cancel(Q){return a(Q),r.return()}},{highWaterMark:2})};var Rt=64*1024,{isFunction:vA}=n,Mr=(({Request:A,Response:e})=>({Request:A,Response:e}))(n.global),{ReadableStream:Ft,TextEncoder:kt}=n.global,Ut=(A,...e)=>{try{return!!A(...e)}catch{return!1}},Hr=A=>{A=n.merge.call({skipUndefined:!0},Mr,A);let{fetch:e,Request:t,Response:I}=A,r=e?vA(e):typeof fetch=="function",i=vA(t),o=vA(I);if(!r)return!1;let a=r&&vA(Ft),Q=r&&(typeof kt=="function"?(l=>c=>l.encode(c))(new kt):async l=>new Uint8Array(await new t(l).arrayBuffer())),C=i&&a&&Ut(()=>{let l=!1,c=new t(h.origin,{body:new Ft,method:"POST",get duplex(){return l=!0,"half"}}),E=c.headers.has("Content-Type");return c.body!=null&&c.body.cancel(),l&&!E}),g=o&&a&&Ut(()=>n.isReadableStream(new I("").body)),s={stream:g&&(l=>l.body)};r&&["text","arrayBuffer","blob","formData","stream"].forEach(l=>{!s[l]&&(s[l]=(c,E)=>{let p=c&&c[l];if(p)return p.call(c);throw new u(`Response type '${l}' is not supported`,u.ERR_NOT_SUPPORT,E)})});let f=async l=>{if(l==null)return 0;if(n.isBlob(l))return l.size;if(n.isSpecCompliantForm(l))return(await new t(h.origin,{method:"POST",body:l}).arrayBuffer()).byteLength;if(n.isArrayBufferView(l)||n.isArrayBuffer(l))return l.byteLength;if(n.isURLSearchParams(l)&&(l=l+""),n.isString(l))return(await Q(l)).byteLength},B=async(l,c)=>{let E=n.toFiniteNumber(l.getContentLength());return E??f(c)};return async l=>{let{url:c,method:E,data:p,signal:J,cancelToken:D,timeout:y,onDownloadProgress:k,onUploadProgress:Z,responseType:M,headers:BA,withCredentials:kA="same-origin",fetchOptions:Oe}=jA(l),qe=e||fetch;M=M?(M+"").toLowerCase():"text";let UA=St([J,D&&D.toAbortSignal()],y),QA=null,V=UA&&UA.unsubscribe&&(()=>{UA.unsubscribe()}),Te;try{if(Z&&C&&E!=="get"&&E!=="head"&&(Te=await B(BA,p))!==0){let H=new t(c,{method:"POST",body:p,duplex:"half"}),AA;if(n.isFormData(p)&&(AA=H.headers.get("content-type"))&&BA.setContentType(AA),H.body){let[te,NA]=De(Te,nA(ye(Z)));p=Se(H.body,Rt,te,NA)}}n.isString(kA)||(kA=kA?"include":"omit");let U=i&&"credentials"in t.prototype;if(n.isFormData(p)){let H=BA.getContentType();H&&/^multipart\/form-data/i.test(H)&&!/boundary=/i.test(H)&&BA.delete("content-type")}let Ke={...Oe,signal:UA,method:E.toUpperCase(),headers:BA.normalize().toJSON(),body:p,duplex:"half",credentials:U?kA:void 0};QA=i&&new t(c,Ke);let j=await(i?qe(QA,Oe):qe(c,Ke)),Pe=g&&(M==="stream"||M==="response");if(g&&(k||Pe&&V)){let H={};["status","statusText","headers"].forEach(xe=>{H[xe]=j[xe]});let AA=n.toFiniteNumber(j.headers.get("content-length")),[te,NA]=k&&De(AA,nA(ye(k),!0))||[];j=new I(Se(j.body,Rt,te,()=>{NA&&NA(),V&&V()}),H)}M=M||"text";let rI=await s[n.findKey(s,M)||"text"](j,l);return!Pe&&V&&V(),await new Promise((H,AA)=>{DA(H,AA,{data:rI,headers:S.from(j.headers),status:j.status,statusText:j.statusText,config:l,request:QA})})}catch(U){throw V&&V(),U&&U.name==="TypeError"&&/Load failed|fetch/i.test(U.message)?Object.assign(new u("Network Error",u.ERR_NETWORK,l,QA,U&&U.response),{cause:U.cause||U}):u.from(U,U&&U.code,l,QA,U&&U.response)}}},Yr=new Map,Re=A=>{let e=A&&A.env||{},{fetch:t,Request:I,Response:r}=e,i=[I,r,t],o=i.length,a=o,Q,C,g=Yr;for(;a--;)Q=i[a],C=g.get(Q),C===void 0&&g.set(Q,C=a?new Map:Hr(e)),g=C;return C},Hg=Re();var Fe={http:KA,xhr:mt,fetch:{get:Re}};n.forEach(Fe,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var Nt=A=>`- ${A}`,qr=A=>n.isFunction(A)||A===null||A===!1;function Tr(A,e){A=n.isArray(A)?A:[A];let{length:t}=A,I,r,i={};for(let o=0;o<t;o++){I=A[o];let a;if(r=I,!qr(I)&&(r=Fe[(a=String(I)).toLowerCase()],r===void 0))throw new u(`Unknown adapter '${a}'`);if(r&&(n.isFunction(r)||(r=r.get(e))))break;i[a||"#"+o]=r}if(!r){let o=Object.entries(i).map(([Q,C])=>`adapter ${Q} `+(C===!1?"is not supported by the environment":"is not available in the build")),a=t?o.length>1?`since :
`+o.map(Nt).join(`
`):" "+Nt(o[0]):"as no adapter specified";throw new u("There is no suitable adapter to dispatch the request "+a,"ERR_NOT_SUPPORT")}return r}var _A={getAdapter:Tr,adapters:Fe};function ke(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new x(null,A)}function ZA(A){return ke(A),A.headers=S.from(A.headers),A.data=pA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),_A.getAdapter(A.adapter||oA.adapter,A)(A).then(function(I){return ke(A),I.data=pA.call(A,A.transformResponse,I),I.headers=S.from(I.headers),I},function(I){return hA(I)||(ke(A),I&&I.response&&(I.response.data=pA.call(A,A.transformResponse,I.response),I.response.headers=S.from(I.response.headers))),Promise.reject(I)})}var VA="1.15.2";var XA={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{XA[A]=function(I){return typeof I===A||"a"+(e<1?"n ":" ")+A}});var Gt={};XA.transitional=function(e,t,I){function r(i,o){return"[Axios v"+VA+"] Transitional option '"+i+"'"+o+(I?". "+I:"")}return(i,o,a)=>{if(e===!1)throw new u(r(o," has been removed"+(t?" in "+t:"")),u.ERR_DEPRECATED);return t&&!Gt[o]&&(Gt[o]=!0,console.warn(r(o," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(i,o,a):!0}};XA.spelling=function(e){return(t,I)=>(console.warn(`${I} is likely a misspelling of ${e}`),!0)};function Kr(A,e,t){if(typeof A!="object")throw new u("options must be an object",u.ERR_BAD_OPTION_VALUE);let I=Object.keys(A),r=I.length;for(;r-- >0;){let i=I[r],o=Object.prototype.hasOwnProperty.call(e,i)?e[i]:void 0;if(o){let a=A[i],Q=a===void 0||o(a,i,A);if(Q!==!0)throw new u("option "+i+" must be "+Q,u.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new u("Unknown option "+i,u.ERR_BAD_OPTION)}}var wA={assertOptions:Kr,validators:XA};var Y=wA.validators,aA=class{constructor(e){this.defaults=e||{},this.interceptors={request:new Qe,response:new Qe}}async request(e,t){try{return await this._request(e,t)}catch(I){if(I instanceof Error){let r={};Error.captureStackTrace?Error.captureStackTrace(r):r=new Error;let i=(()=>{if(!r.stack)return"";let o=r.stack.indexOf(`
`);return o===-1?"":r.stack.slice(o+1)})();try{if(!I.stack)I.stack=i;else if(i){let o=i.indexOf(`
`),a=o===-1?-1:i.indexOf(`
`,o+1),Q=a===-1?"":i.slice(a+1);String(I.stack).endsWith(Q)||(I.stack+=`
`+i)}}catch{}}throw I}}_request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=K(this.defaults,t);let{transitional:I,paramsSerializer:r,headers:i}=t;I!==void 0&&wA.assertOptions(I,{silentJSONParsing:Y.transitional(Y.boolean),forcedJSONParsing:Y.transitional(Y.boolean),clarifyTimeoutError:Y.transitional(Y.boolean),legacyInterceptorReqResOrdering:Y.transitional(Y.boolean)},!1),r!=null&&(n.isFunction(r)?t.paramsSerializer={serialize:r}:wA.assertOptions(r,{encode:Y.function,serialize:Y.function},!0)),t.allowAbsoluteUrls!==void 0||(this.defaults.allowAbsoluteUrls!==void 0?t.allowAbsoluteUrls=this.defaults.allowAbsoluteUrls:t.allowAbsoluteUrls=!0),wA.assertOptions(t,{baseUrl:Y.spelling("baseURL"),withXsrfToken:Y.spelling("withXSRFToken")},!0),t.method=(t.method||this.defaults.method||"get").toLowerCase();let o=i&&n.merge(i.common,i[t.method]);i&&n.forEach(["delete","get","head","post","put","patch","common"],l=>{delete i[l]}),t.headers=S.concat(o,i);let a=[],Q=!0;this.interceptors.request.forEach(function(c){if(typeof c.runWhen=="function"&&c.runWhen(t)===!1)return;Q=Q&&c.synchronous;let E=t.transitional||rA;E&&E.legacyInterceptorReqResOrdering?a.unshift(c.fulfilled,c.rejected):a.push(c.fulfilled,c.rejected)});let C=[];this.interceptors.response.forEach(function(c){C.push(c.fulfilled,c.rejected)});let g,s=0,f;if(!Q){let l=[ZA.bind(this),void 0];for(l.unshift(...a),l.push(...C),f=l.length,g=Promise.resolve(t);s<f;)g=g.then(l[s++],l[s++]);return g}f=a.length;let B=t;for(;s<f;){let l=a[s++],c=a[s++];try{B=l(B)}catch(E){c.call(this,E);break}}try{g=ZA.call(this,B)}catch(l){return Promise.reject(l)}for(s=0,f=C.length;s<f;)g=g.then(C[s++],C[s++]);return g}getUri(e){e=K(this.defaults,e);let t=yA(e.baseURL,e.url,e.allowAbsoluteUrls);return uA(t,e.params,e.paramsSerializer)}};n.forEach(["delete","get","head","options"],function(e){aA.prototype[e]=function(t,I){return this.request(K(I||{},{method:e,url:t,data:(I||{}).data}))}});n.forEach(["post","put","patch"],function(e){function t(I){return function(i,o,a){return this.request(K(a||{},{method:e,headers:I?{"Content-Type":"multipart/form-data"}:{},url:i,data:o}))}}aA.prototype[e]=t(),aA.prototype[e+"Form"]=t(!0)});var mA=aA;var Ue=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,o=new Promise(a=>{I.subscribe(a),i=a}).then(r);return o.cancel=function(){I.unsubscribe(i)},o},e(function(i,o,a){I.reason||(I.reason=new x(i,o,a),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)}toAbortSignal(){let e=new AbortController,t=I=>{e.abort(I)};return this.subscribe(t),e.signal.unsubscribe=()=>this.unsubscribe(t),e.signal}static source(){let e;return{token:new A(function(r){e=r}),cancel:e}}},bt=Ue;function Ne(A){return function(t){return A.apply(null,t)}}function Ge(A){return n.isObject(A)&&A.isAxiosError===!0}var be={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,WebServerIsDown:521,ConnectionTimedOut:522,OriginIsUnreachable:523,TimeoutOccurred:524,SslHandshakeFailed:525,InvalidSslCertificate:526};Object.entries(be).forEach(([A,e])=>{be[e]=A});var Lt=be;function Jt(A){let e=new mA(A),t=EA(mA.prototype.request,e);return n.extend(t,mA.prototype,e,{allOwnKeys:!0}),n.extend(t,e,null,{allOwnKeys:!0}),t.create=function(r){return Jt(K(A,r))},t}var w=Jt(oA);w.Axios=mA;w.CanceledError=x;w.CancelToken=bt;w.isCancel=hA;w.VERSION=VA;w.toFormData=v;w.AxiosError=u;w.Cancel=w.CanceledError;w.all=function(e){return Promise.all(e)};w.spread=Ne;w.isAxiosError=Ge;w.mergeConfig=K;w.AxiosHeaders=S;w.formToJSON=A=>xA(n.isHTMLForm(A)?new FormData(A):A);w.getAdapter=_A.getAdapter;w.HttpStatusCode=Lt;w.default=w;var sA=w;var{Axios:Mn,AxiosError:Hn,CanceledError:Yn,isCancel:On,CancelToken:qn,VERSION:Tn,all:Kn,Cancel:Pn,isAxiosError:xn,spread:Wn,toFormData:jn,AxiosHeaders:vn,HttpStatusCode:_n,formToJSON:Zn,getAdapter:Vn,mergeConfig:Xn}=sA;async function Pr(A,e){let t=A,I=null;if(t==null)I=new Worker(new URL("./web-workers/itk-wasm-pipeline.worker.js",import.meta.url),{type:"module"});else if(t.startsWith("http")){let r=await sA.get(t,{responseType:"blob",params:e}),i=URL.createObjectURL(r.data);I=new Worker(i,{type:"module"})}else I=new Worker(t,{type:"module"});return I}var SA=Pr;function Mt(A){let e=ge(A),t=A;return t.terminated=!1,t.workerProxy=e,t.originalTerminate=t.terminate,t.terminate=()=>{t.terminated=!0,t.workerProxy[oe](),t.originalTerminate()},{workerProxy:e,worker:t}}async function xr(A,e,t){let I;if(A!=null){let i=A;return i.workerProxy!==void 0?(I=i.workerProxy,{workerProxy:I,worker:i}):Mt(A)}let r=await SA(e,t);return Mt(r)}var Ht=xr;var RA,W,Je,Le={env:{emscripten_notify_memory_growth:function(A){Je=new Uint8Array(W.exports.memory.buffer)}}},zA=class{init(){return RA||(typeof fetch<"u"?RA=fetch("data:application/wasm;base64,"+Yt).then(e=>e.arrayBuffer()).then(e=>WebAssembly.instantiate(e,Le)).then(this._init):RA=WebAssembly.instantiate(Buffer.from(Yt,"base64"),Le).then(this._init),RA)}_init(e){W=e.instance,Le.env.emscripten_notify_memory_growth(0)}decode(e,t=0){if(!W)throw new Error("ZSTDDecoder: Await .init() before decoding.");let I=e.byteLength,r=W.exports.malloc(I);Je.set(e,r),t=t||Number(W.exports.ZSTD_findDecompressedSize(r,I));let i=W.exports.malloc(t),o=W.exports.ZSTD_decompress(i,t,r,I),a=Je.slice(i,i+o);return W.exports.free(r),W.exports.free(i),a}},Yt="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";var Ot=new zA,qt=!1;async function Wr(A,e,t){let I="unknown";typeof A!="string"?I=A.href:A.startsWith("http")?I=A:I=typeof e<"u"?`${e}/${A}`:A,I.endsWith(".js")&&(I=I.substring(0,I.length-3)),I.endsWith(".wasm")&&(I=I.substring(0,I.length-5)),I.endsWith(".wasm.zst")&&(I=I.substring(0,I.length-9));let r=`${I}.wasm`,i=await sA.get(`${r}.zst`,{responseType:"arraybuffer",params:t});qt||(await Ot.init(),qt=!0);let a=Ot.decode(new Uint8Array(i.data)).buffer;return(await import(`${I}.js`)).default({wasmBinary:a})}var Tt=Wr;var Kt=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 Wt=typeof globalThis.SharedArrayBuffer=="function",Pt=new TextEncoder,xt=new TextDecoder("utf-8");function jr(A,e){let t={flags:"r",encoding:"binary"},I=A.fs_open(e,t.flags),i=A.fs_stat(e).size,o=null;Wt?o=new SharedArrayBuffer(i):o=new ArrayBuffer(i);let a=new Uint8Array(o);return A.fs_read(I,a,0,i,0),A.fs_close(I),a}function jt(A,e,t){let I=null;Wt?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 m(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])>>>0,A.HEAPU8.set(new Uint8Array(e.buffer),r)),r}function _(A,e,t){let I=JSON.stringify(e),r=A.lengthBytesUTF8(I)+1,i=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,r])>>>0;A.stringToUTF8(I,i,r)}function R(A,e,t,I){let r=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,e,t])>>>0,i=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,e,t]),o=jt(A,r,i);return P(I,o.buffer)}function FA(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e])>>>0,I=A.UTF8ToString(t);return JSON.parse(I)}function vr(A,e,t,I){I!=null&&I.length>0&&I.forEach(function(C,g){switch(C.type){case d.TextStream:{let s=Pt.encode(C.data.data),f=m(A,s,g,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};_(A,B,g);break}case d.JsonCompatible:{let s=Pt.encode(JSON.stringify(C.data)),f=m(A,s,g,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};_(A,B,g);break}case d.BinaryStream:{let s=C.data.data,f=m(A,s,g,0),B={size:s.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};_(A,B,g);break}case d.TextFile:{A.fs_writeFile(C.data.path,C.data.data);break}case d.BinaryFile:{A.fs_writeFile(C.data.path,C.data.data);break}case d.Image:{let s=C.data,f=m(A,s.data,g,0),B=m(A,s.direction,g,1),l=typeof s.metadata?.entries<"u"?Array.from(s.metadata.entries()):[],c={imageType:s.imageType,name:s.name,origin:s.origin,spacing:s.spacing,direction:`data:application/vnd.itk.address,0:${B}`,size:s.size,data:`data:application/vnd.itk.address,0:${f}`,metadata:l};_(A,c,g);break}case d.Mesh:{let s=C.data,f=m(A,s.points,g,0),B=m(A,s.cells,g,1),l=m(A,s.pointData,g,2),c=m(A,s.cellData,g,3),E={meshType:s.meshType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,numberOfCells:s.numberOfCells,cells:`data:application/vnd.itk.address,0:${B}`,cellBufferSize:s.cellBufferSize,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${l}`,numberOfCellPixels:s.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${c}`};_(A,E,g);break}case d.PointSet:{let s=C.data,f=m(A,s.points,g,0),B=m(A,s.pointData,g,1),l={pointSetType:s.pointSetType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${B}`};_(A,l,g);break}case d.TransformList:{let s=C.data,f=[],B=0;s.forEach(l=>{let c="",E="";l.transformType.transformParameterization!=="Composite"&&(c=`data:application/vnd.itk.address,0:${m(A,l.fixedParameters,g,B)}`,B+=1,E=`data:application/vnd.itk.address,0:${m(A,l.parameters,g,B)}`,B+=1);let p={transformType:l.transformType,numberOfFixedParameters:l.numberOfFixedParameters,numberOfParameters:l.numberOfParameters,name:l.name,inputSpaceName:l.inputSpaceName,outputSpaceName:l.outputSpaceName,parameters:E,fixedParameters:c};f.push(p)}),_(A,f,g);break}case d.PolyData:{let s=C.data,f=m(A,s.points,g,0),B=m(A,s.vertices,g,1),l=m(A,s.lines,g,2),c=m(A,s.polygons,g,3),E=m(A,s.triangleStrips,g,4),p=m(A,s.pointData,g,5),J=m(A,s.pointData,g,6),D={polyDataType:s.polyDataType,name:s.name,numberOfPoints:s.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,verticesBufferSize:s.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${B}`,linesBufferSize:s.linesBufferSize,lines:`data:application/vnd.itk.address,0:${l}`,polygonsBufferSize:s.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${c}`,triangleStripsBufferSize:s.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${E}`,numberOfPointPixels:s.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${p}`,numberOfCellPixels:s.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${J}`};_(A,D,g);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 o=A.getModuleStdout(),a=A.getModuleStderr(),Q=[];return t!=null&&t.length>0&&i===0&&t.forEach(function(C,g){let s=null;switch(C.type){case d.TextStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0])>>>0,l=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]),c=new Uint8Array(A.HEAPU8.buffer,B,l);s={data:xt.decode(c)};break}case d.JsonCompatible:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0])>>>0,l=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]),c=new Uint8Array(A.HEAPU8.buffer,B,l);s=JSON.parse(xt.decode(c));break}case d.BinaryStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,g,0])>>>0,l=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,g,0]);s={data:jt(A,B,l)};break}case d.TextFile:{s={path:C.data.path,data:A.fs_readFile(C.data.path,{encoding:"utf8"})};break}case d.BinaryFile:{s={path:C.data.path,data:jr(A,C.data.path)};break}case d.Image:{let B=FA(A,g);B.data=R(A,g,0,B.imageType.componentType),B.direction=R(A,g,1,X.Float64),B.metadata=new Map(B.metadata),s=B;break}case d.Mesh:{let B=FA(A,g);B.numberOfPoints>0?B.points=R(A,g,0,B.meshType.pointComponentType):B.points=P(B.meshType.pointComponentType,new ArrayBuffer(0)),B.numberOfCells>0?B.cells=R(A,g,1,B.meshType.cellComponentType):B.cells=P(B.meshType.cellComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=R(A,g,2,B.meshType.pointPixelComponentType):B.pointData=P(B.meshType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=R(A,g,3,B.meshType.cellPixelComponentType):B.cellData=P(B.meshType.cellPixelComponentType,new ArrayBuffer(0)),s=B;break}case d.PointSet:{let B=FA(A,g);B.numberOfPoints>0?B.points=R(A,g,0,B.pointSetType.pointComponentType):B.points=P(B.pointSetType.pointComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=R(A,g,1,B.pointSetType.pointPixelComponentType):B.pointData=P(B.pointSetType.pointPixelComponentType,new ArrayBuffer(0)),s=B;break}case d.TransformList:{let B=FA(A,g),l=0;B.forEach((c,E)=>{c.transformType.transformParameterization!=="Composite"&&(c.numberOfFixedParameters>0&&(B[E].fixedParameters=R(A,g,l,X.Float64)),l+=1,c.numberOfParameters>0&&(B[E].parameters=R(A,g,l,c.transformType.parametersValueType)),l+=1)}),s=B;break}case d.PolyData:{let B=FA(A,g);B.numberOfPoints>0?B.points=R(A,g,0,X.Float32):B.points=new Float32Array,B.verticesBufferSize>0?B.vertices=R(A,g,1,N.UInt32):B.vertices=new Uint32Array,B.linesBufferSize>0?B.lines=R(A,g,2,N.UInt32):B.lines=new Uint32Array,B.polygonsBufferSize>0?B.polygons=R(A,g,3,N.UInt32):B.polygons=new Uint32Array,B.triangleStripsBufferSize>0?B.triangleStrips=R(A,g,4,N.UInt32):B.triangleStrips=new Uint32Array,B.numberOfPointPixels>0?B.pointData=R(A,g,5,B.polyDataType.pointPixelComponentType):B.pointData=P(B.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=R(A,g,6,B.polyDataType.cellPixelComponentType):B.cellData=P(B.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),s=B;break}default:throw Error("Unsupported output InterfaceType")}let f={type:C.type,data:s};Q.push(f)}),{returnValue:i,stdout:o,stderr:a,outputs:Q}}var vt=vr;var _r=typeof globalThis.SharedArrayBuffer<"u";function Zr(A,e){if(A==null)return[];let t=[];for(let I=0;I<A.length;I++){let r=Vr(A[I],e);r!==null&&t.push(r)}return t}function Vr(A,e){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),_r&&t instanceof SharedArrayBuffer?null:e?t:t.slice(0)}var _t=Zr;function Xr(A){return[A.data,A.direction]}var Zt=Xr;function zr(A){return[A.points,A.pointData,A.cells,A.cellData]}var Vt=zr;function $r(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var Xt=$r;var Ai;function $A(){return Ai}var ei;function zt(){return ei}var ti;function Ae(){return ti}var Me=new Map;function Ii(){let A=Ae();return typeof A>"u"&&(A=null),A}function $t(){let A=$A();return typeof A>"u"&&(A=new URL("/pipelines",document.location.origin).href),A}function ee(){let A=zt();return typeof A>"u"&&(A={}),A}async function ri(A,e,t){let I=A,r=A;if(typeof A!="string"&&(I=new URL(A.href),r=I.href),Me.has(r))return Me.get(r);{let i=await Tt(A,e?.toString()??$t(),t??ee());return Me.set(r,i),i}}async function ii(A,e,t,I,r){if(!await Kt()){let E="WebAssembly SIMD support is required -- please update your browser.";throw alert(E),new Error(E)}let i=r?.webWorker??null;if(i===!1){let E=await ri(A.toString(),r?.pipelineBaseUrl,r?.pipelineQueryParams??ee());return vt(E,e,t,I)}let o=i,a=r?.pipelineWorkerUrl??Ii(),Q=typeof a!="string"&&typeof a?.href<"u"?a.href:a,{workerProxy:C,worker:g}=await Ht(o,Q,r?.pipelineQueryParams??ee());o=g;let s=[];I!=null&&I.length>0&&I.forEach(function(E){if(E.type===d.BinaryStream){let p=E.data.data;s.push(p)}else if(E.type===d.BinaryFile){let p=E.data.data;s.push(p)}else if(E.type===d.Image){let p=E.data;p.data!==null&&s.push(...Zt(p))}else if(E.type===d.Mesh){let p=E.data;s.push(...Vt(p))}else if(E.type===d.PolyData){let p=E.data;s.push(...Xt(p))}});let f=r?.pipelineBaseUrl??$t(),B=typeof f!="string"&&typeof f?.href<"u"?f.href:f,l=I!=null?ne(I,_t(s,r?.noCopy)):null,c=await C.runPipeline(A.toString(),B,e,t,l,r?.pipelineQueryParams??ee());return{returnValue:c.returnValue,stdout:c.stdout,stderr:c.stderr,outputs:c.outputs,webWorker:o}}var L=ii;var oi=null;function AI(){return oi}var He,gi=`https://cdn.jsdelivr.net/npm/@itk-wasm/downsample@${Ie}/dist/pipelines`;function Pa(A){He=A}function O(){if(typeof He<"u")return He;let A=$A();return typeof A<"u"?A:gi}var Ye,ni=null;function eI(A){Ye=A}function b(){if(typeof Ye<"u")return Ye;let A=Ae();return typeof A<"u"?A:ni}var CA=null;async function tI(){let A=b(),e=typeof A!="string"&&typeof A?.href<"u"?A.href:A;CA=await SA(e)}function Va(A){CA=A}async function q(){if(CA!==null)return CA.terminated&&await tI(),CA;let A=AI();return A!==null?A:(await tI(),CA)}async function ai(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),typeof e.shrinkFactors<"u"){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async l=>{r.push(l.toString())}))}typeof e.informationOnly<"u"&&e.informationOnly&&r.push("--information-only");let a="downsample-bin-shrink",Q=e?.webWorker;Q===void 0&&(Q=await q());let{webWorker:C,returnValue:g,stderr:s,outputs:f}=await L(a,r,t,I,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:Q,noCopy:e?.noCopy});if(g!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:f[0]?.data}}var si=ai;async function Ci(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),typeof e.shrinkFactors<"u"){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async l=>{r.push(l.toString())}))}if(typeof e.cropRadius<"u"){if(e.cropRadius.length<2)throw new Error('"crop-radius" option must have a length > 2');r.push("--crop-radius"),await Promise.all(e.cropRadius.map(async l=>{r.push(l.toString())}))}let a="downsample-label-image",Q=e?.webWorker;Q===void 0&&(Q=await q());let{webWorker:C,returnValue:g,stderr:s,outputs:f}=await L(a,r,t,I,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:Q,noCopy:e?.noCopy});if(g!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:f[0]?.data}}var Bi=Ci;async function Qi(A={shrinkFactors:[2,2]}){let e=[{type:d.JsonCompatible}],t=[],I=[];if(I.push("0"),I.push("--memory-io"),typeof A.shrinkFactors<"u"){if(A.shrinkFactors.length<1)throw new Error('"shrink-factors" option must have a length > 1');I.push("--shrink-factors"),await Promise.all(A.shrinkFactors.map(async f=>{I.push(f.toString())}))}let i="downsample-sigma",o=A?.webWorker;o===void 0&&(o=await q());let{webWorker:a,returnValue:Q,stderr:C,outputs:g}=await L(i,I,e,t,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:o,noCopy:A?.noCopy});if(Q!==0&&C!=="")throw new Error(C);return{webWorker:a,sigma:g[0]?.data}}var Ei=Qi;async function li(A,e={shrinkFactors:[2,2]}){let t=[{type:d.Image}],I=[{type:d.Image,data:A}],r=[];if(r.push("0"),r.push("0"),r.push("--memory-io"),typeof e.shrinkFactors<"u"){if(e.shrinkFactors.length<2)throw new Error('"shrink-factors" option must have a length > 2');r.push("--shrink-factors"),await Promise.all(e.shrinkFactors.map(async l=>{r.push(l.toString())}))}if(typeof e.cropRadius<"u"){if(e.cropRadius.length<2)throw new Error('"crop-radius" option must have a length > 2');r.push("--crop-radius"),await Promise.all(e.cropRadius.map(async l=>{r.push(l.toString())}))}let a="downsample",Q=e?.webWorker;Q===void 0&&(Q=await q());let{webWorker:C,returnValue:g,stderr:s,outputs:f}=await L(a,r,t,I,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:Q,noCopy:e?.noCopy});if(g!==0&&s!=="")throw new Error(s);return{webWorker:C,downsampled:f[0]?.data}}var ci=li;async function fi(A={size:[1,1],sigma:[1,1]}){let e=[{type:d.JsonCompatible}],t=[],I=[];if(I.push("0"),I.push("--memory-io"),typeof A.size<"u"){if(A.size.length<1)throw new Error('"size" option must have a length > 1');I.push("--size"),await Promise.all(A.size.map(async f=>{I.push(f.toString())}))}if(typeof A.sigma<"u"){if(A.sigma.length<1)throw new Error('"sigma" option must have a length > 1');I.push("--sigma"),await Promise.all(A.sigma.map(async f=>{I.push(f.toString())}))}typeof A.maxKernelWidth<"u"&&I.push("--max-kernel-width",A.maxKernelWidth.toString()),typeof A.maxKernelError<"u"&&I.push("--max-kernel-error",A.maxKernelError.toString());let i="gaussian-kernel-radius",o=A?.webWorker;o===void 0&&(o=await q());let{webWorker:a,returnValue:Q,stderr:C,outputs:g}=await L(i,I,e,t,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:o,noCopy:A?.noCopy});if(Q!==0&&C!=="")throw new Error(C);return{webWorker:a,radius:g[0]?.data}}var ui=fi;async function di(A,e,t,I={}){let r=[{type:d.JsonCompatible}],i=[{type:d.TransformList,data:A},{type:d.Image,data:e},{type:d.Image,data:t}],o=[];o.push("0"),o.push("1"),o.push("2"),o.push("0"),o.push("--memory-io"),typeof I.padding<"u"&&o.push("--padding",I.padding.toString());let s="resample-bounding-box",f=I?.webWorker;f===void 0&&(f=await q());let{webWorker:B,returnValue:l,stderr:c,outputs:E}=await L(s,o,r,i,{pipelineBaseUrl:O(),pipelineWorkerUrl:b(),webWorker:f,noCopy:I?.noCopy});if(l!==0&&c!=="")throw new Error(c);return{webWorker:B,boundingBox:E[0]?.data}}var pi=di;var II='data:text/javascript;charset=utf-8,var qe=Object.defineProperty;var Me=(A,t)=>{for(var e in t)qe(A,e,{get:t[e],enumerable:!0})};var Lt=Symbol("Comlink.proxy"),Oe=Symbol("Comlink.endpoint"),Te=Symbol("Comlink.releaseProxy"),XA=Symbol("Comlink.finalizer"),SA=Symbol("Comlink.thrown"),bt=A=>typeof A=="object"&&A!==null||typeof A=="function",Ke={canHandle:A=>bt(A)&&A[Lt],serialize(A){let{port1:t,port2:e}=new MessageChannel;return UA(A,t),[e,[e]]},deserialize(A){return A.start(),We(A)}},xe={canHandle:A=>bt(A)&&SA in A,serialize({value:A}){let t;return A instanceof Error?t={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:t={isError:!1,value:A},[t,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},Jt=new Map([["proxy",Ke],["throw",xe]]);function Pe(A,t){for(let e of A)if(t===e||e==="*"||e instanceof RegExp&&e.test(t))return!0;return!1}function UA(A,t=globalThis,e=["*"]){t.addEventListener("message",function I(r){if(!r||!r.data)return;if(!Pe(e,r.origin)){console.warn(`Invalid origin \'${r.origin}\' for comlink proxy`);return}let{id:o,type:g,path:s}=Object.assign({path:[]},r.data),c=(r.data.argumentList||[]).map(_),B;try{let i=s.slice(0,-1).reduce((l,C)=>l[C],A),a=s.reduce((l,C)=>l[C],A);switch(g){case"GET":B=a;break;case"SET":i[s.slice(-1)[0]]=_(r.data.value),B=!0;break;case"APPLY":B=a.apply(i,c);break;case"CONSTRUCT":{let l=new a(...c);B=Xe(l)}break;case"ENDPOINT":{let{port1:l,port2:C}=new MessageChannel;UA(A,C),B=vA(l,[l])}break;case"RELEASE":B=void 0;break;default:return}}catch(i){B={value:i,[SA]:0}}Promise.resolve(B).catch(i=>({value:i,[SA]:0})).then(i=>{let[a,l]=NA(i);t.postMessage(Object.assign(Object.assign({},a),{id:o}),l),g==="RELEASE"&&(t.removeEventListener("message",I),Ht(t),XA in A&&typeof A[XA]=="function"&&A[XA]())}).catch(i=>{let[a,l]=NA({value:new TypeError("Unserializable return value"),[SA]:0});t.postMessage(Object.assign(Object.assign({},a),{id:o}),l)})}),t.start&&t.start()}function je(A){return A.constructor.name==="MessagePort"}function Ht(A){je(A)&&A.close()}function We(A,t){return zA(A,[],t)}function pA(A){if(A)throw new Error("Proxy has been released and is not useable")}function Yt(A){return z(A,{type:"RELEASE"}).then(()=>{Ht(A)})}var RA=new WeakMap,FA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let t=(RA.get(A)||0)-1;RA.set(A,t),t===0&&Yt(A)});function _e(A,t){let e=(RA.get(t)||0)+1;RA.set(t,e),FA&&FA.register(A,t,A)}function Ze(A){FA&&FA.unregister(A)}function zA(A,t=[],e=function(){}){let I=!1,r=new Proxy(e,{get(o,g){if(pA(I),g===Te)return()=>{Ze(r),Yt(A),I=!0};if(g==="then"){if(t.length===0)return{then:()=>r};let s=z(A,{type:"GET",path:t.map(c=>c.toString())}).then(_);return s.then.bind(s)}return zA(A,[...t,g])},set(o,g,s){pA(I);let[c,B]=NA(s);return z(A,{type:"SET",path:[...t,g].map(i=>i.toString()),value:c},B).then(_)},apply(o,g,s){pA(I);let c=t[t.length-1];if(c===Oe)return z(A,{type:"ENDPOINT"}).then(_);if(c==="bind")return zA(A,t.slice(0,-1));let[B,i]=kt(s);return z(A,{type:"APPLY",path:t.map(a=>a.toString()),argumentList:B},i).then(_)},construct(o,g){pA(I);let[s,c]=kt(g);return z(A,{type:"CONSTRUCT",path:t.map(B=>B.toString()),argumentList:s},c).then(_)}});return _e(r,A),r}function Ve(A){return Array.prototype.concat.apply([],A)}function kt(A){let t=A.map(NA);return[t.map(e=>e[0]),Ve(t.map(e=>e[1]))]}var qt=new WeakMap;function vA(A,t){return qt.set(A,t),A}function Xe(A){return Object.assign(A,{[Lt]:!0})}function NA(A){for(let[t,e]of Jt)if(e.canHandle(A)){let[I,r]=e.serialize(A);return[{type:"HANDLER",name:t,value:I},r]}return[{type:"RAW",value:A},qt.get(A)||[]]}function _(A){switch(A.type){case"HANDLER":return Jt.get(A.name).deserialize(A.value);case"RAW":return A.value}}function z(A,t,e){return new Promise(I=>{let r=ze();A.addEventListener("message",function o(g){!g.data||!g.data.id||g.data.id!==r||(A.removeEventListener("message",o),I(g.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:r},t),e)})}function ze(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function nA(A,t){return function(){return A.apply(t,arguments)}}var{toString:ve}=Object.prototype,{getPrototypeOf:kA}=Object,{iterator:LA,toStringTag:xt}=Symbol,bA=(A=>t=>{let e=ve.call(t);return A[e]||(A[e]=e.slice(8,-1).toLowerCase())})(Object.create(null)),Y=A=>(A=A.toLowerCase(),t=>bA(t)===A),JA=A=>t=>typeof t===A,{isArray:$}=Array,v=JA("undefined");function sA(A){return A!==null&&!v(A)&&A.constructor!==null&&!v(A.constructor)&&G(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var Pt=Y("ArrayBuffer");function $e(A){let t;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?t=ArrayBuffer.isView(A):t=A&&A.buffer&&Pt(A.buffer),t}var AI=JA("string"),G=JA("function"),jt=JA("number"),aA=A=>A!==null&&typeof A=="object",tI=A=>A===!0||A===!1,GA=A=>{if(bA(A)!=="object")return!1;let t=kA(A);return(t===null||t===Object.prototype||Object.getPrototypeOf(t)===null)&&!(xt in A)&&!(LA in A)},eI=A=>{if(!aA(A)||sA(A))return!1;try{return Object.keys(A).length===0&&Object.getPrototypeOf(A)===Object.prototype}catch{return!1}},II=Y("Date"),rI=Y("File"),oI=A=>!!(A&&typeof A.uri<"u"),gI=A=>A&&typeof A.getParts<"u",iI=Y("Blob"),nI=Y("FileList"),sI=A=>aA(A)&&G(A.pipe);function aI(){return typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{}}var Ot=aI(),Tt=typeof Ot.FormData<"u"?Ot.FormData:void 0,CI=A=>{if(!A)return!1;if(Tt&&A instanceof Tt)return!0;let t=kA(A);if(!t||t===Object.prototype||!G(A.append))return!1;let e=bA(A);return e==="formdata"||e==="object"&&G(A.toString)&&A.toString()==="[object FormData]"},BI=Y("URLSearchParams"),[QI,EI,cI,fI]=["ReadableStream","Request","Response","Headers"].map(Y),lI=A=>A.trim?A.trim():A.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,"");function CA(A,t,{allOwnKeys:e=!1}={}){if(A===null||typeof A>"u")return;let I,r;if(typeof A!="object"&&(A=[A]),$(A))for(I=0,r=A.length;I<r;I++)t.call(null,A[I],I,A);else{if(sA(A))return;let o=e?Object.getOwnPropertyNames(A):Object.keys(A),g=o.length,s;for(I=0;I<g;I++)s=o[I],t.call(null,A[s],s,A)}}function Wt(A,t){if(sA(A))return null;t=t.toLowerCase();let e=Object.keys(A),I=e.length,r;for(;I-- >0;)if(r=e[I],t===r.toLowerCase())return r;return null}var Z=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,_t=A=>!v(A)&&A!==Z;function $A(){let{caseless:A,skipUndefined:t}=_t(this)&&this||{},e={},I=(r,o)=>{if(o==="__proto__"||o==="constructor"||o==="prototype")return;let g=A&&Wt(e,o)||o;GA(e[g])&&GA(r)?e[g]=$A(e[g],r):GA(r)?e[g]=$A({},r):$(r)?e[g]=r.slice():(!t||!v(r))&&(e[g]=r)};for(let r=0,o=arguments.length;r<o;r++)arguments[r]&&CA(arguments[r],I);return e}var uI=(A,t,e,{allOwnKeys:I}={})=>(CA(t,(r,o)=>{e&&G(r)?Object.defineProperty(A,o,{value:nA(r,e),writable:!0,enumerable:!0,configurable:!0}):Object.defineProperty(A,o,{value:r,writable:!0,enumerable:!0,configurable:!0})},{allOwnKeys:I}),A),dI=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),DI=(A,t,e,I)=>{A.prototype=Object.create(t.prototype,I),Object.defineProperty(A.prototype,"constructor",{value:A,writable:!0,enumerable:!1,configurable:!0}),Object.defineProperty(A,"super",{value:t.prototype}),e&&Object.assign(A.prototype,e)},hI=(A,t,e,I)=>{let r,o,g,s={};if(t=t||{},A==null)return t;do{for(r=Object.getOwnPropertyNames(A),o=r.length;o-- >0;)g=r[o],(!I||I(g,A,t))&&!s[g]&&(t[g]=A[g],s[g]=!0);A=e!==!1&&kA(A)}while(A&&(!e||e(A,t))&&A!==Object.prototype);return t},yI=(A,t,e)=>{A=String(A),(e===void 0||e>A.length)&&(e=A.length),e-=t.length;let I=A.indexOf(t,e);return I!==-1&&I===e},wI=A=>{if(!A)return null;if($(A))return A;let t=A.length;if(!jt(t))return null;let e=new Array(t);for(;t-- >0;)e[t]=A[t];return e},mI=(A=>t=>A&&t instanceof A)(typeof Uint8Array<"u"&&kA(Uint8Array)),pI=(A,t)=>{let I=(A&&A[LA]).call(A),r;for(;(r=I.next())&&!r.done;){let o=r.value;t.call(A,o[0],o[1])}},SI=(A,t)=>{let e,I=[];for(;(e=A.exec(t))!==null;)I.push(e);return I},RI=Y("HTMLFormElement"),FI=A=>A.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,function(e,I,r){return I.toUpperCase()+r}),Kt=(({hasOwnProperty:A})=>(t,e)=>A.call(t,e))(Object.prototype),NI=Y("RegExp"),Zt=(A,t)=>{let e=Object.getOwnPropertyDescriptors(A),I={};CA(e,(r,o)=>{let g;(g=t(r,o,A))!==!1&&(I[o]=g||r)}),Object.defineProperties(A,I)},UI=A=>{Zt(A,(t,e)=>{if(G(A)&&["arguments","caller","callee"].indexOf(e)!==-1)return!1;let I=A[e];if(G(I)){if(t.enumerable=!1,"writable"in t){t.writable=!1;return}t.set||(t.set=()=>{throw Error("Can not rewrite read-only method \'"+e+"\'")})}})},GI=(A,t)=>{let e={},I=r=>{r.forEach(o=>{e[o]=!0})};return $(A)?I(A):I(String(A).split(t)),e},kI=()=>{},LI=(A,t)=>A!=null&&Number.isFinite(A=+A)?A:t;function bI(A){return!!(A&&G(A.append)&&A[xt]==="FormData"&&A[LA])}var JI=A=>{let t=new Array(10),e=(I,r)=>{if(aA(I)){if(t.indexOf(I)>=0)return;if(sA(I))return I;if(!("toJSON"in I)){t[r]=I;let o=$(I)?[]:{};return CA(I,(g,s)=>{let c=e(g,r+1);!v(c)&&(o[s]=c)}),t[r]=void 0,o}}return I};return e(A,0)},HI=Y("AsyncFunction"),YI=A=>A&&(aA(A)||G(A))&&G(A.then)&&G(A.catch),Vt=((A,t)=>A?setImmediate:t?((e,I)=>(Z.addEventListener("message",({source:r,data:o})=>{r===Z&&o===e&&I.length&&I.shift()()},!1),r=>{I.push(r),Z.postMessage(e,"*")}))(`axios@${Math.random()}`,[]):e=>setTimeout(e))(typeof setImmediate=="function",G(Z.postMessage)),qI=typeof queueMicrotask<"u"?queueMicrotask.bind(Z):typeof process<"u"&&process.nextTick||Vt,MI=A=>A!=null&&G(A[LA]),n={isArray:$,isArrayBuffer:Pt,isBuffer:sA,isFormData:CI,isArrayBufferView:$e,isString:AI,isNumber:jt,isBoolean:tI,isObject:aA,isPlainObject:GA,isEmptyObject:eI,isReadableStream:QI,isRequest:EI,isResponse:cI,isHeaders:fI,isUndefined:v,isDate:II,isFile:rI,isReactNativeBlob:oI,isReactNative:gI,isBlob:iI,isRegExp:NI,isFunction:G,isStream:sI,isURLSearchParams:BI,isTypedArray:mI,isFileList:nI,forEach:CA,merge:$A,extend:uI,trim:lI,stripBOM:dI,inherits:DI,toFlatObject:hI,kindOf:bA,kindOfTest:Y,endsWith:yI,toArray:wI,forEachEntry:pI,matchAll:SI,isHTMLForm:RI,hasOwnProperty:Kt,hasOwnProp:Kt,reduceDescriptors:Zt,freezeMethods:UI,toObjectSet:GI,toCamelCase:FI,noop:kI,toFiniteNumber:LI,findKey:Wt,global:Z,isContextDefined:_t,isSpecCompliantForm:bI,toJSONObject:JI,isAsyncFn:HI,isThenable:YI,setImmediate:Vt,asap:qI,isIterable:MI};var F=class A extends Error{static from(t,e,I,r,o,g){let s=new A(t.message,e||t.code,I,r,o);return s.cause=t,s.name=t.name,t.status!=null&&s.status==null&&(s.status=t.status),g&&Object.assign(s,g),s}constructor(t,e,I,r,o){super(t),Object.defineProperty(this,"message",{value:t,enumerable:!0,writable:!0,configurable:!0}),this.name="AxiosError",this.isAxiosError=!0,e&&(this.code=e),I&&(this.config=I),r&&(this.request=r),o&&(this.response=o,this.status=o.status)}toJSON(){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:n.toJSONObject(this.config),code:this.code,status:this.status}}};F.ERR_BAD_OPTION_VALUE="ERR_BAD_OPTION_VALUE";F.ERR_BAD_OPTION="ERR_BAD_OPTION";F.ECONNABORTED="ECONNABORTED";F.ETIMEDOUT="ETIMEDOUT";F.ERR_NETWORK="ERR_NETWORK";F.ERR_FR_TOO_MANY_REDIRECTS="ERR_FR_TOO_MANY_REDIRECTS";F.ERR_DEPRECATED="ERR_DEPRECATED";F.ERR_BAD_RESPONSE="ERR_BAD_RESPONSE";F.ERR_BAD_REQUEST="ERR_BAD_REQUEST";F.ERR_CANCELED="ERR_CANCELED";F.ERR_NOT_SUPPORT="ERR_NOT_SUPPORT";F.ERR_INVALID_URL="ERR_INVALID_URL";F.ERR_FORM_DATA_DEPTH_EXCEEDED="ERR_FORM_DATA_DEPTH_EXCEEDED";var u=F;var HA=null;function tt(A){return n.isPlainObject(A)||n.isArray(A)}function Xt(A){return n.endsWith(A,"[]")?A.slice(0,-2):A}function At(A,t,e){return A?A.concat(t).map(function(r,o){return r=Xt(r),!e&&o?"["+r+"]":r}).join(e?".":""):t}function OI(A){return n.isArray(A)&&!A.some(tt)}var TI=n.toFlatObject(n,{},null,function(t){return/^is[A-Z]/.test(t)});function KI(A,t,e){if(!n.isObject(A))throw new TypeError("target must be an object");t=t||new(HA||FormData),e=n.toFlatObject(e,{metaTokens:!0,dots:!1,indexes:!1},!1,function(E,d){return!n.isUndefined(d[E])});let I=e.metaTokens,r=e.visitor||a,o=e.dots,g=e.indexes,s=e.Blob||typeof Blob<"u"&&Blob,c=e.maxDepth===void 0?100:e.maxDepth,B=s&&n.isSpecCompliantForm(t);if(!n.isFunction(r))throw new TypeError("visitor must be a function");function i(f){if(f===null)return"";if(n.isDate(f))return f.toISOString();if(n.isBoolean(f))return f.toString();if(!B&&n.isBlob(f))throw new u("Blob is not supported. Use a Buffer instead.");return n.isArrayBuffer(f)||n.isTypedArray(f)?B&&typeof Blob=="function"?new Blob([f]):Buffer.from(f):f}function a(f,E,d){let L=f;if(n.isReactNative(t)&&n.isReactNativeBlob(f))return t.append(At(d,E,o),i(f)),!1;if(f&&!d&&typeof f=="object"){if(n.endsWith(E,"{}"))E=I?E:E.slice(0,-2),f=JSON.stringify(f);else if(n.isArray(f)&&OI(f)||(n.isFileList(f)||n.endsWith(E,"[]"))&&(L=n.toArray(f)))return E=Xt(E),L.forEach(function(w,N){!(n.isUndefined(w)||w===null)&&t.append(g===!0?At([E],N,o):g===null?E:E+"[]",i(w))}),!1}return tt(f)?!0:(t.append(At(d,E,o),i(f)),!1)}let l=[],C=Object.assign(TI,{defaultVisitor:a,convertValue:i,isVisitable:tt});function Q(f,E,d=0){if(!n.isUndefined(f)){if(d>c)throw new u("Object is too deeply nested ("+d+" levels). Max depth: "+c,u.ERR_FORM_DATA_DEPTH_EXCEEDED);if(l.indexOf(f)!==-1)throw Error("Circular reference detected in "+E.join("."));l.push(f),n.forEach(f,function(y,w){(!(n.isUndefined(y)||y===null)&&r.call(t,y,n.isString(w)?w.trim():w,E,C))===!0&&Q(y,E?E.concat(w):[w],d+1)}),l.pop()}}if(!n.isObject(A))throw new TypeError("data must be an object");return Q(A),t}var x=KI;function zt(A){let t={"!":"%2521","\'":"%2527","(":"%2528",")":"%2529","~":"%257E","%2520":"+"};return encodeURIComponent(A).replace(/[!\'()~]|%2520/g,function(I){return t[I]})}function vt(A,t){this._pairs=[],A&&x(A,this,t)}var $t=vt.prototype;$t.append=function(t,e){this._pairs.push([t,e])};$t.toString=function(t){let e=t?function(I){return t.call(this,I,zt)}:zt;return this._pairs.map(function(r){return e(r[0])+"="+e(r[1])},"").join("&")};var YA=vt;function xI(A){return encodeURIComponent(A).replace(/%253A/gi,":").replace(/%2524/g,"$").replace(/%252C/gi,",").replace(/%2520/g,"+")}function BA(A,t,e){if(!t)return A;let I=e&&e.encode||xI,r=n.isFunction(e)?{serialize:e}:e,o=r&&r.serialize,g;if(o?g=o(t,r):g=n.isURLSearchParams(t)?t.toString():new YA(t,r).toString(I),g){let s=A.indexOf("%23");s!==-1&&(A=A.slice(0,s)),A+=(A.indexOf("?")===-1?"?":"&")+g}return A}var et=class{constructor(){this.handlers=[]}use(t,e,I){return this.handlers.push({fulfilled:t,rejected:e,synchronous:I?I.synchronous:!1,runWhen:I?I.runWhen:null}),this.handlers.length-1}eject(t){this.handlers[t]&&(this.handlers[t]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(t){n.forEach(this.handlers,function(I){I!==null&&t(I)})}},It=et;var AA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1,legacyInterceptorReqResOrdering:!0};var Ae=typeof URLSearchParams<"u"?URLSearchParams:YA;var te=typeof FormData<"u"?FormData:null;var ee=typeof Blob<"u"?Blob:null;var Ie={isBrowser:!0,classes:{URLSearchParams:Ae,FormData:te,Blob:ee},protocols:["http","https","file","blob","url","data"]};var gt={};Me(gt,{hasBrowserEnv:()=>ot,hasStandardBrowserEnv:()=>PI,hasStandardBrowserWebWorkerEnv:()=>jI,navigator:()=>rt,origin:()=>WI});var ot=typeof window<"u"&&typeof document<"u",rt=typeof navigator=="object"&&navigator||void 0,PI=ot&&(!rt||["ReactNative","NativeScript","NS"].indexOf(rt.product)<0),jI=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function",WI=ot&&window.location.href||"http://localhost";var h={...gt,...Ie};function it(A,t){return x(A,new h.classes.URLSearchParams,{visitor:function(e,I,r,o){return h.isNode&&n.isBuffer(e)?(this.append(I,e.toString("base64")),!1):o.defaultVisitor.apply(this,arguments)},...t})}function _I(A){return n.matchAll(/\\w+|\\[(\\w*)]/g,A).map(t=>t[0]==="[]"?"":t[1]||t[0])}function ZI(A){let t={},e=Object.keys(A),I,r=e.length,o;for(I=0;I<r;I++)o=e[I],t[o]=A[o];return t}function VI(A){function t(e,I,r,o){let g=e[o++];if(g==="__proto__")return!0;let s=Number.isFinite(+g),c=o>=e.length;return g=!g&&n.isArray(r)?r.length:g,c?(n.hasOwnProp(r,g)?r[g]=n.isArray(r[g])?r[g].concat(I):[r[g],I]:r[g]=I,!s):((!r[g]||!n.isObject(r[g]))&&(r[g]=[]),t(e,I,r[g],o)&&n.isArray(r[g])&&(r[g]=ZI(r[g])),!s)}if(n.isFormData(A)&&n.isFunction(A.entries)){let e={};return n.forEachEntry(A,(I,r)=>{t(_I(I),r,e,0)}),e}return null}var qA=VI;var tA=(A,t)=>A!=null&&n.hasOwnProp(A,t)?A[t]:void 0;function XI(A,t,e){if(n.isString(A))try{return(t||JSON.parse)(A),n.trim(A)}catch(I){if(I.name!=="SyntaxError")throw I}return(e||JSON.stringify)(A)}var nt={transitional:AA,adapter:["xhr","http","fetch"],transformRequest:[function(t,e){let I=e.getContentType()||"",r=I.indexOf("application/json")>-1,o=n.isObject(t);if(o&&n.isHTMLForm(t)&&(t=new FormData(t)),n.isFormData(t))return r?JSON.stringify(qA(t)):t;if(n.isArrayBuffer(t)||n.isBuffer(t)||n.isStream(t)||n.isFile(t)||n.isBlob(t)||n.isReadableStream(t))return t;if(n.isArrayBufferView(t))return t.buffer;if(n.isURLSearchParams(t))return e.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),t.toString();let s;if(o){let c=tA(this,"formSerializer");if(I.indexOf("application/x-www-form-urlencoded")>-1)return it(t,c).toString();if((s=n.isFileList(t))||I.indexOf("multipart/form-data")>-1){let B=tA(this,"env"),i=B&&B.FormData;return x(s?{"files[]":t}:t,i&&new i,c)}}return o||r?(e.setContentType("application/json",!1),XI(t)):t}],transformResponse:[function(t){let e=tA(this,"transitional")||nt.transitional,I=e&&e.forcedJSONParsing,r=tA(this,"responseType"),o=r==="json";if(n.isResponse(t)||n.isReadableStream(t))return t;if(t&&n.isString(t)&&(I&&!r||o)){let s=!(e&&e.silentJSONParsing)&&o;try{return JSON.parse(t,tA(this,"parseReviver"))}catch(c){if(s)throw c.name==="SyntaxError"?u.from(c,u.ERR_BAD_RESPONSE,this,null,tA(this,"response")):c}}return t}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:h.classes.FormData,Blob:h.classes.Blob},validateStatus:function(t){return t>=200&&t<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};n.forEach(["delete","get","head","post","put","patch"],A=>{nt.headers[A]={}});var eA=nt;var zI=n.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"]),re=A=>{let t={},e,I,r;return A&&A.split(`%0A`).forEach(function(g){r=g.indexOf(":"),e=g.substring(0,r).trim().toLowerCase(),I=g.substring(r+1).trim(),!(!e||t[e]&&zI[e])&&(e==="set-cookie"?t[e]?t[e].push(I):t[e]=[I]:t[e]=t[e]?t[e]+", "+I:I)}),t};var oe=Symbol("internals"),vI=/[^\\x09\\x20-\\x7E\\x80-\\xFF]/g;function $I(A){let t=0,e=A.length;for(;t<e;){let I=A.charCodeAt(t);if(I!==9&&I!==32)break;t+=1}for(;e>t;){let I=A.charCodeAt(e-1);if(I!==9&&I!==32)break;e-=1}return t===0&&e===A.length?A:A.slice(t,e)}function QA(A){return A&&String(A).trim().toLowerCase()}function Ar(A){return $I(A.replace(vI,""))}function MA(A){return A===!1||A==null?A:n.isArray(A)?A.map(MA):Ar(String(A))}function tr(A){let t=Object.create(null),e=/([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g,I;for(;I=e.exec(A);)t[I[1]]=I[2];return t}var er=A=>/^[-_a-zA-Z0-9^`|~,!%23$%&\'*+.]+$/.test(A.trim());function st(A,t,e,I,r){if(n.isFunction(I))return I.call(this,t,e);if(r&&(t=e),!!n.isString(t)){if(n.isString(I))return t.indexOf(I)!==-1;if(n.isRegExp(I))return I.test(t)}}function Ir(A){return A.trim().toLowerCase().replace(/([a-z\\d])(\\w*)/g,(t,e,I)=>e.toUpperCase()+I)}function rr(A,t){let e=n.toCamelCase(" "+t);["get","set","has"].forEach(I=>{Object.defineProperty(A,I+e,{value:function(r,o,g){return this[I].call(this,t,r,o,g)},configurable:!0})})}var IA=class{constructor(t){t&&this.set(t)}set(t,e,I){let r=this;function o(s,c,B){let i=QA(c);if(!i)throw new Error("header name must be a non-empty string");let a=n.findKey(r,i);(!a||r[a]===void 0||B===!0||B===void 0&&r[a]!==!1)&&(r[a||c]=MA(s))}let g=(s,c)=>n.forEach(s,(B,i)=>o(B,i,c));if(n.isPlainObject(t)||t instanceof this.constructor)g(t,e);else if(n.isString(t)&&(t=t.trim())&&!er(t))g(re(t),e);else if(n.isObject(t)&&n.isIterable(t)){let s={},c,B;for(let i of t){if(!n.isArray(i))throw TypeError("Object iterator must return a key-value pair");s[B=i[0]]=(c=s[B])?n.isArray(c)?[...c,i[1]]:[c,i[1]]:i[1]}g(s,e)}else t!=null&&o(e,t,I);return this}get(t,e){if(t=QA(t),t){let I=n.findKey(this,t);if(I){let r=this[I];if(!e)return r;if(e===!0)return tr(r);if(n.isFunction(e))return e.call(this,r,I);if(n.isRegExp(e))return e.exec(r);throw new TypeError("parser must be boolean|regexp|function")}}}has(t,e){if(t=QA(t),t){let I=n.findKey(this,t);return!!(I&&this[I]!==void 0&&(!e||st(this,this[I],I,e)))}return!1}delete(t,e){let I=this,r=!1;function o(g){if(g=QA(g),g){let s=n.findKey(I,g);s&&(!e||st(I,I[s],s,e))&&(delete I[s],r=!0)}}return n.isArray(t)?t.forEach(o):o(t),r}clear(t){let e=Object.keys(this),I=e.length,r=!1;for(;I--;){let o=e[I];(!t||st(this,this[o],o,t,!0))&&(delete this[o],r=!0)}return r}normalize(t){let e=this,I={};return n.forEach(this,(r,o)=>{let g=n.findKey(I,o);if(g){e[g]=MA(r),delete e[o];return}let s=t?Ir(o):String(o).trim();s!==o&&delete e[o],e[s]=MA(r),I[s]=!0}),this}concat(...t){return this.constructor.concat(this,...t)}toJSON(t){let e=Object.create(null);return n.forEach(this,(I,r)=>{I!=null&&I!==!1&&(e[r]=t&&n.isArray(I)?I.join(", "):I)}),e}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([t,e])=>t+": "+e).join(`%0A`)}getSetCookie(){return this.get("set-cookie")||[]}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(t){return t instanceof this?t:new this(t)}static concat(t,...e){let I=new this(t);return e.forEach(r=>I.set(r)),I}static accessor(t){let I=(this[oe]=this[oe]={accessors:{}}).accessors,r=this.prototype;function o(g){let s=QA(g);I[s]||(rr(r,g),I[s]=!0)}return n.isArray(t)?t.forEach(o):o(t),this}};IA.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);n.reduceDescriptors(IA.prototype,({value:A},t)=>{let e=t[0].toUpperCase()+t.slice(1);return{get:()=>A,set(I){this[e]=I}}});n.freezeMethods(IA);var S=IA;function EA(A,t){let e=this||eA,I=t||e,r=S.from(I.headers),o=I.data;return n.forEach(A,function(s){o=s.call(e,o,r.normalize(),t?t.status:void 0)}),r.normalize(),o}function cA(A){return!!(A&&A.__CANCEL__)}var at=class extends u{constructor(t,e,I){super(t??"canceled",u.ERR_CANCELED,e,I),this.name="CanceledError",this.__CANCEL__=!0}},M=at;function fA(A,t,e){let I=e.config.validateStatus;!e.status||!I||I(e.status)?A(e):t(new u("Request failed with status code "+e.status,[u.ERR_BAD_REQUEST,u.ERR_BAD_RESPONSE][Math.floor(e.status/100)-4],e.config,e.request,e))}function Ct(A){let t=/^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(A);return t&&t[1]||""}function or(A,t){A=A||10;let e=new Array(A),I=new Array(A),r=0,o=0,g;return t=t!==void 0?t:1e3,function(c){let B=Date.now(),i=I[o];g||(g=B),e[r]=c,I[r]=B;let a=o,l=0;for(;a!==r;)l+=e[a++],a=a%A;if(r=(r+1)%A,r===o&&(o=(o+1)%A),B-g<t)return;let C=i&&B-i;return C?Math.round(l*1e3/C):void 0}}var ge=or;function gr(A,t){let e=0,I=1e3/t,r,o,g=(B,i=Date.now())=>{e=i,r=null,o&&(clearTimeout(o),o=null),A(...B)};return[(...B)=>{let i=Date.now(),a=i-e;a>=I?g(B,i):(r=B,o||(o=setTimeout(()=>{o=null,g(r)},I-a)))},()=>r&&g(r)]}var ie=gr;var rA=(A,t,e=3)=>{let I=0,r=ge(50,250);return ie(o=>{let g=o.loaded,s=o.lengthComputable?o.total:void 0,c=s!=null?Math.min(g,s):g,B=Math.max(0,c-I),i=r(B);I=Math.max(I,c);let a={loaded:c,total:s,progress:s?c/s:void 0,bytes:B,rate:i||void 0,estimated:i&&s?(s-c)/i:void 0,event:o,lengthComputable:s!=null,[t?"download":"upload"]:!0};A(a)},e)},Bt=(A,t)=>{let e=A!=null;return[I=>t[0]({lengthComputable:e,total:A,loaded:I}),t[1]]},Qt=A=>(...t)=>n.asap(()=>A(...t));var ne=h.hasStandardBrowserEnv?((A,t)=>e=>(e=new URL(e,h.origin),A.protocol===e.protocol&&A.host===e.host&&(t||A.port===e.port)))(new URL(h.origin),h.navigator&&/(msie|trident)/i.test(h.navigator.userAgent)):()=>!0;var se=h.hasStandardBrowserEnv?{write(A,t,e,I,r,o,g){if(typeof document>"u")return;let s=[`${A}=${encodeURIComponent(t)}`];n.isNumber(e)&&s.push(`expires=${new Date(e).toUTCString()}`),n.isString(I)&&s.push(`path=${I}`),n.isString(r)&&s.push(`domain=${r}`),o===!0&&s.push("secure"),n.isString(g)&&s.push(`SameSite=${g}`),document.cookie=s.join("; ")},read(A){if(typeof document>"u")return null;let t=document.cookie.match(new RegExp("(?:^|; )"+A+"=([^;]*)"));return t?decodeURIComponent(t[1]):null},remove(A){this.write(A,"",Date.now()-864e5,"/")}}:{write(){},read(){return null},remove(){}};function Et(A){return typeof A!="string"?!1:/^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(A)}function ct(A,t){return t?A.replace(/\\/?\\/$/,"")+"/"+t.replace(/^\\/+/,""):A}function lA(A,t,e){let I=!Et(t);return A&&(I||e===!1)?ct(A,t):t}var ae=A=>A instanceof S?{...A}:A;function q(A,t){t=t||{};let e=Object.create(null);Object.defineProperty(e,"hasOwnProperty",{value:Object.prototype.hasOwnProperty,enumerable:!1,writable:!0,configurable:!0});function I(B,i,a,l){return n.isPlainObject(B)&&n.isPlainObject(i)?n.merge.call({caseless:l},B,i):n.isPlainObject(i)?n.merge({},i):n.isArray(i)?i.slice():i}function r(B,i,a,l){if(n.isUndefined(i)){if(!n.isUndefined(B))return I(void 0,B,a,l)}else return I(B,i,a,l)}function o(B,i){if(!n.isUndefined(i))return I(void 0,i)}function g(B,i){if(n.isUndefined(i)){if(!n.isUndefined(B))return I(void 0,B)}else return I(void 0,i)}function s(B,i,a){if(n.hasOwnProp(t,a))return I(B,i);if(n.hasOwnProp(A,a))return I(void 0,B)}let c={url:o,method:o,data:o,baseURL:g,transformRequest:g,transformResponse:g,paramsSerializer:g,timeout:g,timeoutMessage:g,withCredentials:g,withXSRFToken: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,allowedSocketPaths:g,responseEncoding:g,validateStatus:s,headers:(B,i,a)=>r(ae(B),ae(i),a,!0)};return n.forEach(Object.keys({...A,...t}),function(i){if(i==="__proto__"||i==="constructor"||i==="prototype")return;let a=n.hasOwnProp(c,i)?c[i]:r,l=n.hasOwnProp(A,i)?A[i]:void 0,C=n.hasOwnProp(t,i)?t[i]:void 0,Q=a(l,C,i);n.isUndefined(Q)&&a!==s||(e[i]=Q)}),e}var OA=A=>{let t=q({},A),e=l=>n.hasOwnProp(t,l)?t[l]:void 0,I=e("data"),r=e("withXSRFToken"),o=e("xsrfHeaderName"),g=e("xsrfCookieName"),s=e("headers"),c=e("auth"),B=e("baseURL"),i=e("allowAbsoluteUrls"),a=e("url");if(t.headers=s=S.from(s),t.url=BA(lA(B,a,i),A.params,A.paramsSerializer),c&&s.set("Authorization","Basic "+btoa((c.username||"")+":"+(c.password?unescape(encodeURIComponent(c.password)):""))),n.isFormData(I)){if(h.hasStandardBrowserEnv||h.hasStandardBrowserWebWorkerEnv)s.setContentType(void 0);else if(n.isFunction(I.getHeaders)){let l=I.getHeaders(),C=["content-type","content-length"];Object.entries(l).forEach(([Q,f])=>{C.includes(Q.toLowerCase())&&s.set(Q,f)})}}if(h.hasStandardBrowserEnv&&(n.isFunction(r)&&(r=r(t)),r===!0||r==null&&ne(t.url))){let C=o&&g&&se.read(g);C&&s.set(o,C)}return t};var ir=typeof XMLHttpRequest<"u",Ce=ir&&function(A){return new Promise(function(e,I){let r=OA(A),o=r.data,g=S.from(r.headers).normalize(),{responseType:s,onUploadProgress:c,onDownloadProgress:B}=r,i,a,l,C,Q;function f(){C&&C(),Q&&Q(),r.cancelToken&&r.cancelToken.unsubscribe(i),r.signal&&r.signal.removeEventListener("abort",i)}let E=new XMLHttpRequest;E.open(r.method.toUpperCase(),r.url,!0),E.timeout=r.timeout;function d(){if(!E)return;let y=S.from("getAllResponseHeaders"in E&&E.getAllResponseHeaders()),N={data:!s||s==="text"||s==="json"?E.responseText:E.response,status:E.status,statusText:E.statusText,headers:y,config:A,request:E};fA(function(b){e(b),f()},function(b){I(b),f()},N),E=null}"onloadend"in E?E.onloadend=d:E.onreadystatechange=function(){!E||E.readyState!==4||E.status===0&&!(E.responseURL&&E.responseURL.indexOf("file:")===0)||setTimeout(d)},E.onabort=function(){E&&(I(new u("Request aborted",u.ECONNABORTED,A,E)),E=null)},E.onerror=function(w){let N=w&&w.message?w.message:"Network Error",j=new u(N,u.ERR_NETWORK,A,E);j.event=w||null,I(j),E=null},E.ontimeout=function(){let w=r.timeout?"timeout of "+r.timeout+"ms exceeded":"timeout exceeded",N=r.transitional||AA;r.timeoutErrorMessage&&(w=r.timeoutErrorMessage),I(new u(w,N.clarifyTimeoutError?u.ETIMEDOUT:u.ECONNABORTED,A,E)),E=null},o===void 0&&g.setContentType(null),"setRequestHeader"in E&&n.forEach(g.toJSON(),function(w,N){E.setRequestHeader(N,w)}),n.isUndefined(r.withCredentials)||(E.withCredentials=!!r.withCredentials),s&&s!=="json"&&(E.responseType=r.responseType),B&&([l,Q]=rA(B,!0),E.addEventListener("progress",l)),c&&E.upload&&([a,C]=rA(c),E.upload.addEventListener("progress",a),E.upload.addEventListener("loadend",C)),(r.cancelToken||r.signal)&&(i=y=>{E&&(I(!y||y.type?new M(null,A,E):y),E.abort(),E=null)},r.cancelToken&&r.cancelToken.subscribe(i),r.signal&&(r.signal.aborted?i():r.signal.addEventListener("abort",i)));let L=Ct(r.url);if(L&&h.protocols.indexOf(L)===-1){I(new u("Unsupported protocol "+L+":",u.ERR_BAD_REQUEST,A));return}E.send(o||null)})};var nr=(A,t)=>{let{length:e}=A=A?A.filter(Boolean):[];if(t||e){let I=new AbortController,r,o=function(B){if(!r){r=!0,s();let i=B instanceof Error?B:this.reason;I.abort(i instanceof u?i:new M(i instanceof Error?i.message:i))}},g=t&&setTimeout(()=>{g=null,o(new u(`timeout of ${t}ms exceeded`,u.ETIMEDOUT))},t),s=()=>{A&&(g&&clearTimeout(g),g=null,A.forEach(B=>{B.unsubscribe?B.unsubscribe(o):B.removeEventListener("abort",o)}),A=null)};A.forEach(B=>B.addEventListener("abort",o));let{signal:c}=I;return c.unsubscribe=()=>n.asap(s),c}},Be=nr;var sr=function*(A,t){let e=A.byteLength;if(!t||e<t){yield A;return}let I=0,r;for(;I<e;)r=I+t,yield A.slice(I,r),I=r},ar=async function*(A,t){for await(let e of Cr(A))yield*sr(e,t)},Cr=async function*(A){if(A[Symbol.asyncIterator]){yield*A;return}let t=A.getReader();try{for(;;){let{done:e,value:I}=await t.read();if(e)break;yield I}}finally{await t.cancel()}},ft=(A,t,e,I)=>{let r=ar(A,t),o=0,g,s=c=>{g||(g=!0,I&&I(c))};return new ReadableStream({async pull(c){try{let{done:B,value:i}=await r.next();if(B){s(),c.close();return}let a=i.byteLength;if(e){let l=o+=a;e(l)}c.enqueue(new Uint8Array(i))}catch(B){throw s(B),B}},cancel(c){return s(c),r.return()}},{highWaterMark:2})};var Qe=64*1024,{isFunction:TA}=n,Br=(({Request:A,Response:t})=>({Request:A,Response:t}))(n.global),{ReadableStream:Ee,TextEncoder:ce}=n.global,fe=(A,...t)=>{try{return!!A(...t)}catch{return!1}},Qr=A=>{A=n.merge.call({skipUndefined:!0},Br,A);let{fetch:t,Request:e,Response:I}=A,r=t?TA(t):typeof fetch=="function",o=TA(e),g=TA(I);if(!r)return!1;let s=r&&TA(Ee),c=r&&(typeof ce=="function"?(Q=>f=>Q.encode(f))(new ce):async Q=>new Uint8Array(await new e(Q).arrayBuffer())),B=o&&s&&fe(()=>{let Q=!1,f=new e(h.origin,{body:new Ee,method:"POST",get duplex(){return Q=!0,"half"}}),E=f.headers.has("Content-Type");return f.body!=null&&f.body.cancel(),Q&&!E}),i=g&&s&&fe(()=>n.isReadableStream(new I("").body)),a={stream:i&&(Q=>Q.body)};r&&["text","arrayBuffer","blob","formData","stream"].forEach(Q=>{!a[Q]&&(a[Q]=(f,E)=>{let d=f&&f[Q];if(d)return d.call(f);throw new u(`Response type \'${Q}\' is not supported`,u.ERR_NOT_SUPPORT,E)})});let l=async Q=>{if(Q==null)return 0;if(n.isBlob(Q))return Q.size;if(n.isSpecCompliantForm(Q))return(await new e(h.origin,{method:"POST",body:Q}).arrayBuffer()).byteLength;if(n.isArrayBufferView(Q)||n.isArrayBuffer(Q))return Q.byteLength;if(n.isURLSearchParams(Q)&&(Q=Q+""),n.isString(Q))return(await c(Q)).byteLength},C=async(Q,f)=>{let E=n.toFiniteNumber(Q.getContentLength());return E??l(f)};return async Q=>{let{url:f,method:E,data:d,signal:L,cancelToken:y,timeout:w,onDownloadProgress:N,onUploadProgress:j,responseType:b,headers:gA,withCredentials:yA="same-origin",fetchOptions:St}=OA(Q),Rt=t||fetch;b=b?(b+"").toLowerCase():"text";let wA=Be([L,y&&y.toAbortSignal()],w),iA=null,W=wA&&wA.unsubscribe&&(()=>{wA.unsubscribe()}),Ft;try{if(j&&B&&E!=="get"&&E!=="head"&&(Ft=await C(gA,d))!==0){let J=new e(f,{method:"POST",body:d,duplex:"half"}),X;if(n.isFormData(d)&&(X=J.headers.get("content-type"))&&gA.setContentType(X),J.body){let[VA,mA]=Bt(Ft,rA(Qt(j)));d=ft(J.body,Qe,VA,mA)}}n.isString(yA)||(yA=yA?"include":"omit");let U=o&&"credentials"in e.prototype;if(n.isFormData(d)){let J=gA.getContentType();J&&/^multipart\\/form-data/i.test(J)&&!/boundary=/i.test(J)&&gA.delete("content-type")}let Nt={...St,signal:wA,method:E.toUpperCase(),headers:gA.normalize().toJSON(),body:d,duplex:"half",credentials:U?yA:void 0};iA=o&&new e(f,Nt);let K=await(o?Rt(iA,St):Rt(f,Nt)),Ut=i&&(b==="stream"||b==="response");if(i&&(N||Ut&&W)){let J={};["status","statusText","headers"].forEach(Gt=>{J[Gt]=K[Gt]});let X=n.toFiniteNumber(K.headers.get("content-length")),[VA,mA]=N&&Bt(X,rA(Qt(N),!0))||[];K=new I(ft(K.body,Qe,VA,()=>{mA&&mA(),W&&W()}),J)}b=b||"text";let Ye=await a[n.findKey(a,b)||"text"](K,Q);return!Ut&&W&&W(),await new Promise((J,X)=>{fA(J,X,{data:Ye,headers:S.from(K.headers),status:K.status,statusText:K.statusText,config:Q,request:iA})})}catch(U){throw W&&W(),U&&U.name==="TypeError"&&/Load failed|fetch/i.test(U.message)?Object.assign(new u("Network Error",u.ERR_NETWORK,Q,iA,U&&U.response),{cause:U.cause||U}):u.from(U,U&&U.code,Q,iA,U&&U.response)}}},Er=new Map,lt=A=>{let t=A&&A.env||{},{fetch:e,Request:I,Response:r}=t,o=[I,r,e],g=o.length,s=g,c,B,i=Er;for(;s--;)c=o[s],B=i.get(c),B===void 0&&i.set(c,B=s?new Map:Qr(t)),i=B;return B},Mg=lt();var ut={http:HA,xhr:Ce,fetch:{get:lt}};n.forEach(ut,(A,t)=>{if(A){try{Object.defineProperty(A,"name",{value:t})}catch{}Object.defineProperty(A,"adapterName",{value:t})}});var le=A=>`- ${A}`,fr=A=>n.isFunction(A)||A===null||A===!1;function lr(A,t){A=n.isArray(A)?A:[A];let{length:e}=A,I,r,o={};for(let g=0;g<e;g++){I=A[g];let s;if(r=I,!fr(I)&&(r=ut[(s=String(I)).toLowerCase()],r===void 0))throw new u(`Unknown adapter \'${s}\'`);if(r&&(n.isFunction(r)||(r=r.get(t))))break;o[s||"%23"+g]=r}if(!r){let g=Object.entries(o).map(([c,B])=>`adapter ${c} `+(B===!1?"is not supported by the environment":"is not available in the build")),s=e?g.length>1?`since :%0A`+g.map(le).join(`%0A`):" "+le(g[0]):"as no adapter specified";throw new u("There is no suitable adapter to dispatch the request "+s,"ERR_NOT_SUPPORT")}return r}var KA={getAdapter:lr,adapters:ut};function dt(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new M(null,A)}function xA(A){return dt(A),A.headers=S.from(A.headers),A.data=EA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),KA.getAdapter(A.adapter||eA.adapter,A)(A).then(function(I){return dt(A),I.data=EA.call(A,A.transformResponse,I),I.headers=S.from(I.headers),I},function(I){return cA(I)||(dt(A),I&&I.response&&(I.response.data=EA.call(A,A.transformResponse,I.response),I.response.headers=S.from(I.response.headers))),Promise.reject(I)})}var PA="1.15.2";var jA={};["object","boolean","number","function","string","symbol"].forEach((A,t)=>{jA[A]=function(I){return typeof I===A||"a"+(t<1?"n ":" ")+A}});var ue={};jA.transitional=function(t,e,I){function r(o,g){return"[Axios v"+PA+"] Transitional option \'"+o+"\'"+g+(I?". "+I:"")}return(o,g,s)=>{if(t===!1)throw new u(r(g," has been removed"+(e?" in "+e:"")),u.ERR_DEPRECATED);return e&&!ue[g]&&(ue[g]=!0,console.warn(r(g," has been deprecated since v"+e+" and will be removed in the near future"))),t?t(o,g,s):!0}};jA.spelling=function(t){return(e,I)=>(console.warn(`${I} is likely a misspelling of ${t}`),!0)};function ur(A,t,e){if(typeof A!="object")throw new u("options must be an object",u.ERR_BAD_OPTION_VALUE);let I=Object.keys(A),r=I.length;for(;r-- >0;){let o=I[r],g=Object.prototype.hasOwnProperty.call(t,o)?t[o]:void 0;if(g){let s=A[o],c=s===void 0||g(s,o,A);if(c!==!0)throw new u("option "+o+" must be "+c,u.ERR_BAD_OPTION_VALUE);continue}if(e!==!0)throw new u("Unknown option "+o,u.ERR_BAD_OPTION)}}var uA={assertOptions:ur,validators:jA};var H=uA.validators,oA=class{constructor(t){this.defaults=t||{},this.interceptors={request:new It,response:new It}}async request(t,e){try{return await this._request(t,e)}catch(I){if(I instanceof Error){let r={};Error.captureStackTrace?Error.captureStackTrace(r):r=new Error;let o=(()=>{if(!r.stack)return"";let g=r.stack.indexOf(`%0A`);return g===-1?"":r.stack.slice(g+1)})();try{if(!I.stack)I.stack=o;else if(o){let g=o.indexOf(`%0A`),s=g===-1?-1:o.indexOf(`%0A`,g+1),c=s===-1?"":o.slice(s+1);String(I.stack).endsWith(c)||(I.stack+=`%0A`+o)}}catch{}}throw I}}_request(t,e){typeof t=="string"?(e=e||{},e.url=t):e=t||{},e=q(this.defaults,e);let{transitional:I,paramsSerializer:r,headers:o}=e;I!==void 0&&uA.assertOptions(I,{silentJSONParsing:H.transitional(H.boolean),forcedJSONParsing:H.transitional(H.boolean),clarifyTimeoutError:H.transitional(H.boolean),legacyInterceptorReqResOrdering:H.transitional(H.boolean)},!1),r!=null&&(n.isFunction(r)?e.paramsSerializer={serialize:r}:uA.assertOptions(r,{encode:H.function,serialize:H.function},!0)),e.allowAbsoluteUrls!==void 0||(this.defaults.allowAbsoluteUrls!==void 0?e.allowAbsoluteUrls=this.defaults.allowAbsoluteUrls:e.allowAbsoluteUrls=!0),uA.assertOptions(e,{baseUrl:H.spelling("baseURL"),withXsrfToken:H.spelling("withXSRFToken")},!0),e.method=(e.method||this.defaults.method||"get").toLowerCase();let g=o&&n.merge(o.common,o[e.method]);o&&n.forEach(["delete","get","head","post","put","patch","common"],Q=>{delete o[Q]}),e.headers=S.concat(g,o);let s=[],c=!0;this.interceptors.request.forEach(function(f){if(typeof f.runWhen=="function"&&f.runWhen(e)===!1)return;c=c&&f.synchronous;let E=e.transitional||AA;E&&E.legacyInterceptorReqResOrdering?s.unshift(f.fulfilled,f.rejected):s.push(f.fulfilled,f.rejected)});let B=[];this.interceptors.response.forEach(function(f){B.push(f.fulfilled,f.rejected)});let i,a=0,l;if(!c){let Q=[xA.bind(this),void 0];for(Q.unshift(...s),Q.push(...B),l=Q.length,i=Promise.resolve(e);a<l;)i=i.then(Q[a++],Q[a++]);return i}l=s.length;let C=e;for(;a<l;){let Q=s[a++],f=s[a++];try{C=Q(C)}catch(E){f.call(this,E);break}}try{i=xA.call(this,C)}catch(Q){return Promise.reject(Q)}for(a=0,l=B.length;a<l;)i=i.then(B[a++],B[a++]);return i}getUri(t){t=q(this.defaults,t);let e=lA(t.baseURL,t.url,t.allowAbsoluteUrls);return BA(e,t.params,t.paramsSerializer)}};n.forEach(["delete","get","head","options"],function(t){oA.prototype[t]=function(e,I){return this.request(q(I||{},{method:t,url:e,data:(I||{}).data}))}});n.forEach(["post","put","patch"],function(t){function e(I){return function(o,g,s){return this.request(q(s||{},{method:t,headers:I?{"Content-Type":"multipart/form-data"}:{},url:o,data:g}))}}oA.prototype[t]=e(),oA.prototype[t+"Form"]=e(!0)});var dA=oA;var Dt=class A{constructor(t){if(typeof t!="function")throw new TypeError("executor must be a function.");let e;this.promise=new Promise(function(o){e=o});let I=this;this.promise.then(r=>{if(!I._listeners)return;let o=I._listeners.length;for(;o-- >0;)I._listeners[o](r);I._listeners=null}),this.promise.then=r=>{let o,g=new Promise(s=>{I.subscribe(s),o=s}).then(r);return g.cancel=function(){I.unsubscribe(o)},g},t(function(o,g,s){I.reason||(I.reason=new M(o,g,s),e(I.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(t){if(this.reason){t(this.reason);return}this._listeners?this._listeners.push(t):this._listeners=[t]}unsubscribe(t){if(!this._listeners)return;let e=this._listeners.indexOf(t);e!==-1&&this._listeners.splice(e,1)}toAbortSignal(){let t=new AbortController,e=I=>{t.abort(I)};return this.subscribe(e),t.signal.unsubscribe=()=>this.unsubscribe(e),t.signal}static source(){let t;return{token:new A(function(r){t=r}),cancel:t}}},de=Dt;function ht(A){return function(e){return A.apply(null,e)}}function yt(A){return n.isObject(A)&&A.isAxiosError===!0}var wt={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,WebServerIsDown:521,ConnectionTimedOut:522,OriginIsUnreachable:523,TimeoutOccurred:524,SslHandshakeFailed:525,InvalidSslCertificate:526};Object.entries(wt).forEach(([A,t])=>{wt[t]=A});var De=wt;function he(A){let t=new dA(A),e=nA(dA.prototype.request,t);return n.extend(e,dA.prototype,t,{allOwnKeys:!0}),n.extend(e,t,null,{allOwnKeys:!0}),e.create=function(r){return he(q(A,r))},e}var m=he(eA);m.Axios=dA;m.CanceledError=M;m.CancelToken=de;m.isCancel=cA;m.VERSION=PA;m.toFormData=x;m.AxiosError=u;m.Cancel=m.CanceledError;m.all=function(t){return Promise.all(t)};m.spread=ht;m.isAxiosError=yt;m.mergeConfig=q;m.AxiosHeaders=S;m.formToJSON=A=>qA(n.isHTMLForm(A)?new FormData(A):A);m.getAdapter=KA.getAdapter;m.HttpStatusCode=De;m.default=m;var WA=m;var{Axios:Yi,AxiosError:qi,CanceledError:Mi,isCancel:Oi,CancelToken:Ti,VERSION:Ki,all:xi,Cancel:Pi,isAxiosError:ji,spread:Wi,toFormData:_i,AxiosHeaders:Zi,HttpStatusCode:Vi,formToJSON:Xi,getAdapter:zi,mergeConfig:vi}=WA;var DA,T,pt,mt={env:{emscripten_notify_memory_growth:function(A){pt=new Uint8Array(T.exports.memory.buffer)}}},_A=class{init(){return DA||(typeof fetch<"u"?DA=fetch("data:application/wasm;base64,"+ye).then(t=>t.arrayBuffer()).then(t=>WebAssembly.instantiate(t,mt)).then(this._init):DA=WebAssembly.instantiate(Buffer.from(ye,"base64"),mt).then(this._init),DA)}_init(t){T=t.instance,mt.env.emscripten_notify_memory_growth(0)}decode(t,e=0){if(!T)throw new Error("ZSTDDecoder: Await .init() before decoding.");let I=t.byteLength,r=T.exports.malloc(I);pt.set(t,r),e=e||Number(T.exports.ZSTD_findDecompressedSize(r,I));let o=T.exports.malloc(e),g=T.exports.ZSTD_decompress(o,e,r,I),s=pt.slice(o,o+g);return T.exports.free(r),T.exports.free(o),s}},ye="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";var we=new _A,me=!1;async function dr(A,t,e){let I=null;typeof A!="string"?I=A.href:A.startsWith("http")?I=A:I=`${t}/${A}`,I.endsWith(".js")&&(I=I.substring(0,I.length-3)),I.endsWith(".wasm")&&(I=I.substring(0,I.length-5)),I.endsWith(".wasm.zst")&&(I=I.substring(0,I.length-9));let r=`${I}.wasm`,o=await WA.get(`${r}.zst`,{responseType:"arraybuffer",params:e});me||(await we.init(),me=!0);let s=we.decode(new Uint8Array(o.data)).buffer;return(await import(`${I}.js`)).default({wasmBinary:s})}var pe=dr;var ZA=new Map;async function Dr(A,t,e){let I=A,r=A,o=null;return typeof A!="string"&&(I=new URL(A.href),r=I.href),ZA.has(r)?o=await ZA.get(r):(ZA.set(r,pe(I,t,e)),o=await ZA.get(r)),o}var Se=Dr;var hr={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",PointSet:"PointSet",Mesh:"Mesh",PolyData:"PolyData",TransformList:"TransformList",JsonCompatible:"JsonCompatible"},D=hr;var yr={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},k=yr;var wr={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},V=wr;function mr(A,t){let e=null;switch(A){case k.UInt8:{e=new Uint8Array(t);break}case k.Int8:{e=new Int8Array(t);break}case k.UInt16:{e=new Uint16Array(t);break}case k.Int16:{e=new Int16Array(t);break}case k.UInt32:{e=new Uint32Array(t);break}case k.Int32:{e=new Int32Array(t);break}case k.UInt64:{typeof globalThis.BigUint64Array=="function"?e=new BigUint64Array(t):e=new Uint8Array(t);break}case k.Int64:{typeof globalThis.BigInt64Array=="function"?e=new BigInt64Array(t):e=new Uint8Array(t);break}case V.Float32:{e=new Float32Array(t);break}case V.Float64:{e=new Float64Array(t);break}case"null":{e=null;break}case null:{e=null;break}default:throw new Error("Type is not supported as a TypedArray")}return e}var O=mr;var Ne=typeof globalThis.SharedArrayBuffer=="function",Re=new TextEncoder,Fe=new TextDecoder("utf-8");function pr(A,t){let e={flags:"r",encoding:"binary"},I=A.fs_open(t,e.flags),o=A.fs_stat(t).size,g=null;Ne?g=new SharedArrayBuffer(o):g=new ArrayBuffer(o);let s=new Uint8Array(g);return A.fs_read(I,s,0,o,0),A.fs_close(I),s}function Ue(A,t,e){let I=null;Ne?I=new SharedArrayBuffer(e):I=new ArrayBuffer(e);let r=new Uint8Array(I),o=new Uint8Array(A.HEAPU8.buffer,t,e);return r.set(o),r}function p(A,t,e,I){let r=0;return t!==null&&(r=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,e,I,t.buffer.byteLength])>>>0,A.HEAPU8.set(new Uint8Array(t.buffer),r)),r}function P(A,t,e){let I=JSON.stringify(t),r=A.lengthBytesUTF8(I)+1,o=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,e,r])>>>0;A.stringToUTF8(I,o,r)}function R(A,t,e,I){let r=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,t,e])>>>0,o=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,t,e]),g=Ue(A,r,o);return O(I,g.buffer)}function hA(A,t){let e=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,t])>>>0,I=A.UTF8ToString(e);return JSON.parse(I)}function Sr(A,t,e,I){I!=null&&I.length>0&&I.forEach(function(B,i){switch(B.type){case D.TextStream:{let a=Re.encode(B.data.data),l=p(A,a,i,0),C={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};P(A,C,i);break}case D.JsonCompatible:{let a=Re.encode(JSON.stringify(B.data)),l=p(A,a,i,0),C={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};P(A,C,i);break}case D.BinaryStream:{let a=B.data.data,l=p(A,a,i,0),C={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${l}`};P(A,C,i);break}case D.TextFile:{A.fs_writeFile(B.data.path,B.data.data);break}case D.BinaryFile:{A.fs_writeFile(B.data.path,B.data.data);break}case D.Image:{let a=B.data,l=p(A,a.data,i,0),C=p(A,a.direction,i,1),Q=typeof a.metadata?.entries<"u"?Array.from(a.metadata.entries()):[],f={imageType:a.imageType,name:a.name,origin:a.origin,spacing:a.spacing,direction:`data:application/vnd.itk.address,0:${C}`,size:a.size,data:`data:application/vnd.itk.address,0:${l}`,metadata:Q};P(A,f,i);break}case D.Mesh:{let a=B.data,l=p(A,a.points,i,0),C=p(A,a.cells,i,1),Q=p(A,a.pointData,i,2),f=p(A,a.cellData,i,3),E={meshType:a.meshType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,numberOfCells:a.numberOfCells,cells:`data:application/vnd.itk.address,0:${C}`,cellBufferSize:a.cellBufferSize,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${Q}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${f}`};P(A,E,i);break}case D.PointSet:{let a=B.data,l=p(A,a.points,i,0),C=p(A,a.pointData,i,1),Q={pointSetType:a.pointSetType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${C}`};P(A,Q,i);break}case D.TransformList:{let a=B.data,l=[],C=0;a.forEach(Q=>{let f="",E="";Q.transformType.transformParameterization!=="Composite"&&(f=`data:application/vnd.itk.address,0:${p(A,Q.fixedParameters,i,C)}`,C+=1,E=`data:application/vnd.itk.address,0:${p(A,Q.parameters,i,C)}`,C+=1);let d={transformType:Q.transformType,numberOfFixedParameters:Q.numberOfFixedParameters,numberOfParameters:Q.numberOfParameters,name:Q.name,inputSpaceName:Q.inputSpaceName,outputSpaceName:Q.outputSpaceName,parameters:E,fixedParameters:f};l.push(d)}),P(A,l,i);break}case D.PolyData:{let a=B.data,l=p(A,a.points,i,0),C=p(A,a.vertices,i,1),Q=p(A,a.lines,i,2),f=p(A,a.polygons,i,3),E=p(A,a.triangleStrips,i,4),d=p(A,a.pointData,i,5),L=p(A,a.pointData,i,6),y={polyDataType:a.polyDataType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${l}`,verticesBufferSize:a.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${C}`,linesBufferSize:a.linesBufferSize,lines:`data:application/vnd.itk.address,0:${Q}`,polygonsBufferSize:a.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${f}`,triangleStripsBufferSize:a.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${E}`,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${d}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${L}`};P(A,y,i);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let r=A.stackSave(),o=0;try{o=A.callMain(t.slice())}catch(B){throw typeof B=="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(B)):console.error("Build module in Debug mode for exception message information.")),B}finally{A.stackRestore(r)}let g=A.getModuleStdout(),s=A.getModuleStderr(),c=[];return e!=null&&e.length>0&&o===0&&e.forEach(function(B,i){let a=null;switch(B.type){case D.TextStream:{let C=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0])>>>0,Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]),f=new Uint8Array(A.HEAPU8.buffer,C,Q);a={data:Fe.decode(f)};break}case D.JsonCompatible:{let C=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0])>>>0,Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]),f=new Uint8Array(A.HEAPU8.buffer,C,Q);a=JSON.parse(Fe.decode(f));break}case D.BinaryStream:{let C=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,i,0])>>>0,Q=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,i,0]);a={data:Ue(A,C,Q)};break}case D.TextFile:{a={path:B.data.path,data:A.fs_readFile(B.data.path,{encoding:"utf8"})};break}case D.BinaryFile:{a={path:B.data.path,data:pr(A,B.data.path)};break}case D.Image:{let C=hA(A,i);C.data=R(A,i,0,C.imageType.componentType),C.direction=R(A,i,1,V.Float64),C.metadata=new Map(C.metadata),a=C;break}case D.Mesh:{let C=hA(A,i);C.numberOfPoints>0?C.points=R(A,i,0,C.meshType.pointComponentType):C.points=O(C.meshType.pointComponentType,new ArrayBuffer(0)),C.numberOfCells>0?C.cells=R(A,i,1,C.meshType.cellComponentType):C.cells=O(C.meshType.cellComponentType,new ArrayBuffer(0)),C.numberOfPointPixels>0?C.pointData=R(A,i,2,C.meshType.pointPixelComponentType):C.pointData=O(C.meshType.pointPixelComponentType,new ArrayBuffer(0)),C.numberOfCellPixels>0?C.cellData=R(A,i,3,C.meshType.cellPixelComponentType):C.cellData=O(C.meshType.cellPixelComponentType,new ArrayBuffer(0)),a=C;break}case D.PointSet:{let C=hA(A,i);C.numberOfPoints>0?C.points=R(A,i,0,C.pointSetType.pointComponentType):C.points=O(C.pointSetType.pointComponentType,new ArrayBuffer(0)),C.numberOfPointPixels>0?C.pointData=R(A,i,1,C.pointSetType.pointPixelComponentType):C.pointData=O(C.pointSetType.pointPixelComponentType,new ArrayBuffer(0)),a=C;break}case D.TransformList:{let C=hA(A,i),Q=0;C.forEach((f,E)=>{f.transformType.transformParameterization!=="Composite"&&(f.numberOfFixedParameters>0&&(C[E].fixedParameters=R(A,i,Q,V.Float64)),Q+=1,f.numberOfParameters>0&&(C[E].parameters=R(A,i,Q,f.transformType.parametersValueType)),Q+=1)}),a=C;break}case D.PolyData:{let C=hA(A,i);C.numberOfPoints>0?C.points=R(A,i,0,V.Float32):C.points=new Float32Array,C.verticesBufferSize>0?C.vertices=R(A,i,1,k.UInt32):C.vertices=new Uint32Array,C.linesBufferSize>0?C.lines=R(A,i,2,k.UInt32):C.lines=new Uint32Array,C.polygonsBufferSize>0?C.polygons=R(A,i,3,k.UInt32):C.polygons=new Uint32Array,C.triangleStripsBufferSize>0?C.triangleStrips=R(A,i,4,k.UInt32):C.triangleStrips=new Uint32Array,C.numberOfPointPixels>0?C.pointData=R(A,i,5,C.polyDataType.pointPixelComponentType):C.pointData=O(C.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),C.numberOfCellPixels>0?C.cellData=R(A,i,6,C.polyDataType.cellPixelComponentType):C.cellData=O(C.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),a=C;break}default:throw Error("Unsupported output InterfaceType")}let l={type:B.type,data:a};c.push(l)}),{returnValue:o,stdout:g,stderr:s,outputs:c}}var Ge=Sr;var Rr=typeof globalThis.SharedArrayBuffer<"u";function Fr(A,t){if(A==null)return[];let e=[];for(let I=0;I<A.length;I++){let r=Nr(A[I],t);r!==null&&e.push(r)}return e}function Nr(A,t){if(A==null)return null;let e=null;return A.buffer!==void 0?e=A.buffer:A.byteLength!==void 0&&(e=A),Rr&&e instanceof SharedArrayBuffer?null:t?e:e.slice(0)}var ke=Fr;function Ur(A){return[A.data,A.direction]}var Le=Ur;function Gr(A){return[A.points,A.pointData,A.cells,A.cellData]}var be=Gr;function kr(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var Je=kr;async function Lr(A,t,e,I){let r=Ge(A,t,e,I),o=[];return r.outputs.forEach(function(g){if(g.type===D.BinaryStream||g.type===D.BinaryFile){let s=g.data;o.push(s)}else if(g.type===D.Image){let s=g.data;o.push(...Le(s))}else if(g.type===D.Mesh){let s=g.data;o.push(...be(s))}else if(g.type===D.PolyData){let s=g.data;o.push(...Je(s))}}),vA(r,ke(o,!0))}var He=Lr;var br={runPipeline:async function(A,t,e,I,r,o){let g=await Se(A,t,o);return await He(g,e,I,r)}};UA(br);%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';eI(II);export{ci as downsample,si as downsampleBinShrink,Bi as downsampleLabelImage,Ei as downsampleSigma,ui as gaussianKernelRadius,q as getDefaultWebWorker,b as getPipelineWorkerUrl,O as getPipelinesBaseUrl,pi as resampleBoundingBox,Va as setDefaultWebWorker,eI as setPipelineWorkerUrl,Pa as setPipelinesBaseUrl,Ie as version};
/*! 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/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/resample_bounding_box_async.py b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/resample_bounding_box_async.py
new file mode 100644
index 000000000..996624dce
--- /dev/null
+++ b/packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/resample_bounding_box_async.py
@@ -0,0 +1,65 @@
+# 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,
+    TransformList,
+    Image,
+)
+
+async def resample_bounding_box_async(
+    transform: TransformList,
+    fixed: Image,
+    moving: Image,
+    padding: int = 1,
+) -> Any:
+    """Compute the padded moving-image region needed to resample the fixed image grid through a transform
+
+    :param transform: Spatial transform mapping fixed image points into moving image space
+    :type  transform: TransformList
+
+    :param fixed: Fixed image whose grid is resampled (metadata only)
+    :type  fixed: Image
+
+    :param moving: Moving image to be sampled (metadata only)
+    :type  moving: Image
+
+    :param padding: Pixels of padding added per side (default 1 for linear interpolation)
+    :type  padding: int
+
+    :return: The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)
+    :rtype:  Any
+    """
+    js_module = await js_package.js_module
+    web_worker = js_resources.web_worker
+
+    kwargs = {}
+    if padding is not None:
+        kwargs["padding"] = to_js(padding)
+
+    outputs = await js_module.resampleBoundingBox(to_js(transform), to_js(fixed), to_js(moving), webWorker=web_worker, noCopy=True, **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/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/__init__.py b/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/__init__.py
index 594e25e1e..edc72849a 100644
--- a/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/__init__.py
+++ b/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/__init__.py
@@ -7,5 +7,6 @@
 from .downsample_sigma import downsample_sigma
 from .downsample import downsample
 from .gaussian_kernel_radius import gaussian_kernel_radius
+from .resample_bounding_box import resample_bounding_box
 
 from ._version import __version__
diff --git a/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/resample_bounding_box.py b/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/resample_bounding_box.py
new file mode 100644
index 000000000..fd276dccd
--- /dev/null
+++ b/packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/resample_bounding_box.py
@@ -0,0 +1,77 @@
+# Generated file. To retain edits, remove this comment.
+
+from pathlib import Path, PurePosixPath
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from importlib_resources import files as file_resources
+
+_pipeline = None
+
+from itkwasm import (
+    InterfaceTypes,
+    PipelineOutput,
+    PipelineInput,
+    Pipeline,
+    TransformList,
+    Image,
+)
+
+def resample_bounding_box(
+    transform: TransformList,
+    fixed: Image,
+    moving: Image,
+    padding: int = 1,
+) -> Any:
+    """Compute the padded moving-image region needed to resample the fixed image grid through a transform
+
+    :param transform: Spatial transform mapping fixed image points into moving image space
+    :type  transform: TransformList
+
+    :param fixed: Fixed image whose grid is resampled (metadata only)
+    :type  fixed: Image
+
+    :param moving: Moving image to be sampled (metadata only)
+    :type  moving: Image
+
+    :param padding: Pixels of padding added per side (default 1 for linear interpolation)
+    :type  padding: int
+
+    :return: The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)
+    :rtype:  Any
+    """
+    global _pipeline
+    if _pipeline is None:
+        _pipeline = Pipeline(file_resources('itkwasm_downsample_wasi').joinpath(Path('wasm_modules') / Path('resample-bounding-box.wasi.wasm')))
+
+    pipeline_outputs: List[PipelineOutput] = [
+        PipelineOutput(InterfaceTypes.JsonCompatible),
+    ]
+
+    pipeline_inputs: List[PipelineInput] = [
+        PipelineInput(InterfaceTypes.TransformList, transform),
+        PipelineInput(InterfaceTypes.Image, fixed),
+        PipelineInput(InterfaceTypes.Image, moving),
+    ]
+
+    args: List[str] = ['--memory-io',]
+    # Inputs
+    args.append('0')
+    args.append('1')
+    args.append('2')
+    # Outputs
+    bounding_box_name = '0'
+    args.append(bounding_box_name)
+
+    # Options
+    input_count = len(pipeline_inputs)
+    if padding is not None:
+        args.append('--padding')
+        args.append(str(padding))
+
+
+    outputs = _pipeline.run(args, pipeline_outputs, pipeline_inputs)
+
+    result = outputs[0].data
+    return result
+
diff --git a/packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py b/packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py
new file mode 100644
index 000000000..4a21c9ea9
--- /dev/null
+++ b/packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py
@@ -0,0 +1,176 @@
+import json
+
+import numpy as np
+import pytest
+
+from itkwasm import (
+    Image,
+    ImageType,
+    IntTypes,
+    PixelTypes,
+    Transform,
+    TransformType,
+    TransformParameterizations,
+    FloatTypes,
+)
+
+from itkwasm_downsample_wasi import resample_bounding_box
+
+from .common import test_output_path
+
+# The resample-bounding-box pipeline reads ONLY image metadata (size, spacing, origin, direction); the pixel
+# buffers are never dereferenced. These helpers therefore build "metadata-only" images whose data buffer is
+# empty -- the payoff of the pipeline is that a caller can describe two images and a transform with a few numbers
+# and learn exactly which region of the moving image to fetch, without ever holding pixels. There is no
+# higher-level metadata-image helper in itkwasm, so (like the TypeScript test) we construct the Image directly.
+# The helpers are dimension-generic so the same code covers the 2D and 3D cases; the case table below parametrizes
+# the test body rather than copy-pasting a whole test per dimension/transform.
+
+
+def metadata_only_image(size, spacing, origin):
+    """A single-component, uint8 Image of arbitrary dimension with the given geometry and an EMPTY pixel buffer."""
+    dimension = len(size)
+    image_type = ImageType(
+        dimension=dimension,
+        componentType=IntTypes.UInt8,
+        pixelType=PixelTypes.Scalar,
+        components=1,
+    )
+    return Image(
+        imageType=image_type,
+        origin=origin,
+        spacing=spacing,
+        direction=np.eye(dimension, dtype=np.float64),  # identity
+        size=size,
+        data=np.empty((0,), dtype=np.uint8),  # no pixels -- exercise the metadata-only contract
+    )
+
+
+def translation_transform(offset):
+    """A single-entry TransformList holding a float64 TranslationTransform (dimension inferred from the offset).
+
+    itkwasm-transform has no create_translation_transform helper, so the minimal TransformList is built by hand:
+    a Translation has no fixed parameters and its parameters are the per-axis offset.
+    """
+    dimension = len(offset)
+    transform_type = TransformType(
+        transformParameterization=TransformParameterizations.Translation,
+        parametersValueType=FloatTypes.Float64,
+        inputDimension=dimension,
+        outputDimension=dimension,
+    )
+    transform = Transform(
+        transformType=transform_type,
+        numberOfFixedParameters=0,
+        numberOfParameters=dimension,
+        fixedParameters=np.empty((0,), dtype=np.float64),
+        parameters=np.asarray(offset, dtype=np.float64),
+        name="TranslationTransform",
+    )
+    return [transform]
+
+
+def affine_transform(matrix_row_major, translation, center):
+    """A single-entry TransformList holding a float64 AffineTransform.
+
+    ITK's MatrixOffsetTransformBase packs its parameters as the row-major matrix followed by the translation, and
+    its fixed parameters as the center of rotation -- so parameters = [*matrix_row_major, *translation],
+    fixedParameters = center. This exactly mirrors how resample-bounding-box-generate-inputs builds the transform
+    in C++, so the C++, TypeScript, and Python surfaces agree.
+    """
+    dimension = len(translation)
+    transform_type = TransformType(
+        transformParameterization=TransformParameterizations.Affine,
+        parametersValueType=FloatTypes.Float64,
+        inputDimension=dimension,
+        outputDimension=dimension,
+    )
+    parameters = np.asarray(list(matrix_row_major) + list(translation), dtype=np.float64)
+    transform = Transform(
+        transformType=transform_type,
+        numberOfFixedParameters=len(center),
+        numberOfParameters=len(parameters),
+        fixedParameters=np.asarray(center, dtype=np.float64),
+        parameters=parameters,
+        name="AffineTransform",
+    )
+    return [transform]
+
+
+# Cross-surface case table. Every region here is asserted identically by the C++ unit test
+# (resample-bounding-box-test.cxx) and the TypeScript suite, and is exercised end-to-end by the C++ CTests, so the
+# C++, TypeScript, and Python results are provably identical for the same inputs.
+#   2D translation: fixed 16x16 sp(2,2) o(10,20), translation (10,5)          -> corners [20,50] x [25,55]
+#   3D translation: fixed 8^3 sp(2,2,2) o(10,20,30), translation (10,5,3)     -> corners [20,34]x[25,39]x[33,47]
+#   2D rotation    : fixed 20x10 sp(1,1) o(0,0), affine rot(cos.8,sin.6)@(9.5,4.5)+t(10,10) -> [9.2,29.8]x[5.2,23.8]
+# Moving image is spacing (1,1[,1]) origin 0 throughout, so continuous index == physical coordinate.
+CASES = [
+    dict(
+        name="2d-translation",
+        fixed=lambda: metadata_only_image([16, 16], [2, 2], [10, 20]),
+        moving=lambda: metadata_only_image([64, 64], [1, 1], [0, 0]),
+        transform=lambda: translation_transform([10, 5]),
+        corners_min=[20, 25],
+        corners_max=[50, 55],
+        p1=dict(start=[19, 24], size=[33, 33], pmin=[19, 24], pmax=[51, 56]),
+        p0=dict(start=[20, 25], size=[31, 31], pmin=[20, 25], pmax=[50, 55]),
+    ),
+    dict(
+        name="3d-translation",
+        fixed=lambda: metadata_only_image([8, 8, 8], [2, 2, 2], [10, 20, 30]),
+        moving=lambda: metadata_only_image([64, 64, 64], [1, 1, 1], [0, 0, 0]),
+        transform=lambda: translation_transform([10, 5, 3]),
+        corners_min=[20, 25, 33],
+        corners_max=[34, 39, 47],
+        p1=dict(start=[19, 24, 32], size=[17, 17, 17], pmin=[19, 24, 32], pmax=[35, 40, 48]),
+        p0=dict(start=[20, 25, 33], size=[15, 15, 15], pmin=[20, 25, 33], pmax=[34, 39, 47]),
+    ),
+    dict(
+        name="2d-rotation",
+        fixed=lambda: metadata_only_image([20, 10], [1, 1], [0, 0]),
+        moving=lambda: metadata_only_image([64, 64], [1, 1], [0, 0]),
+        transform=lambda: affine_transform([0.8, -0.6, 0.6, 0.8], [10, 10], [9.5, 4.5]),
+        corners_min=[9.2, 5.2],
+        corners_max=[29.8, 23.8],
+        p1=dict(start=[8, 4], size=[24, 22], pmin=[8, 4], pmax=[31, 25]),
+        p0=dict(start=[9, 5], size=[22, 20], pmin=[9, 5], pmax=[30, 24]),
+    ),
+]
+
+
+@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
+def test_resample_bounding_box_region(case):
+    """The reported region tightly bounds the transformed fixed grid, plus symmetric padding.
+
+    Asserts identical regions to the C++ and TypeScript surfaces for the same inputs, across 2D/3D and
+    translation/affine, with metadata-only (empty-buffer) images throughout.
+    """
+    # padding 1 (default): the region bounds the transformed fixed grid plus one pixel per side.
+    padded = resample_bounding_box(case["transform"](), case["fixed"](), case["moving"](), padding=1)
+
+    # Tight corners are padding-independent and match the analytic transformed-grid extremes.
+    assert padded["corners"]["min"] == pytest.approx(case["corners_min"])
+    assert padded["corners"]["max"] == pytest.approx(case["corners_max"])
+
+    assert padded["paddedStartIndex"] == case["p1"]["start"]
+    assert padded["paddedSize"] == case["p1"]["size"]
+    assert padded["paddedCorners"]["min"] == pytest.approx(case["p1"]["pmin"])
+    assert padded["paddedCorners"]["max"] == pytest.approx(case["p1"]["pmax"])
+
+    # padding 0: the empty-data images are accepted (metadata-only contract) and 0 is forwarded (a falsy 0 must
+    # not fall back to the C++ default of 1); the padded corners collapse to the integer-index bound of the tight
+    # corners (equal to the tight corners only when they fall on grid lines -- the translation cases, not the
+    # rotation); and the region is exactly one pixel smaller per side than the padding-1 region (symmetric).
+    tight = resample_bounding_box(case["transform"](), case["fixed"](), case["moving"](), padding=0)
+    assert tight["paddedStartIndex"] == case["p0"]["start"]
+    assert tight["paddedSize"] == case["p0"]["size"]
+    assert tight["paddedCorners"]["min"] == pytest.approx(case["p0"]["pmin"])
+    assert tight["paddedCorners"]["max"] == pytest.approx(case["p0"]["pmax"])
+
+    for axis in range(len(case["corners_min"])):
+        assert tight["paddedStartIndex"][axis] == padded["paddedStartIndex"][axis] + 1
+        assert tight["paddedSize"][axis] == padded["paddedSize"][axis] - 2
+
+    # Persist each case's padded result next to the other Python test outputs for inspection.
+    with open(test_output_path / f"resample-bounding-box-{case['name']}.json", "w") as fp:
+        json.dump(padded, fp)
diff --git a/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/__init__.py b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/__init__.py
index 880dab5f5..07887db57 100644
--- a/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/__init__.py
+++ b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/__init__.py
@@ -12,5 +12,7 @@
 from .downsample import downsample
 from .gaussian_kernel_radius_async import gaussian_kernel_radius_async
 from .gaussian_kernel_radius import gaussian_kernel_radius
+from .resample_bounding_box_async import resample_bounding_box_async
+from .resample_bounding_box import resample_bounding_box
 
 from ._version import __version__
diff --git a/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box.py b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box.py
new file mode 100644
index 000000000..cb2155725
--- /dev/null
+++ b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box.py
@@ -0,0 +1,37 @@
+# Generated file. Do not edit.
+
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from itkwasm import (
+    environment_dispatch,
+    TransformList,
+    Image,
+)
+
+def resample_bounding_box(
+    transform: TransformList,
+    fixed: Image,
+    moving: Image,
+    padding: int = 1,
+) -> Any:
+    """Compute the padded moving-image region needed to resample the fixed image grid through a transform
+
+    :param transform: Spatial transform mapping fixed image points into moving image space
+    :type  transform: TransformList
+
+    :param fixed: Fixed image whose grid is resampled (metadata only)
+    :type  fixed: Image
+
+    :param moving: Moving image to be sampled (metadata only)
+    :type  moving: Image
+
+    :param padding: Pixels of padding added per side (default 1 for linear interpolation)
+    :type  padding: int
+
+    :return: The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)
+    :rtype:  Any
+    """
+    func = environment_dispatch("itkwasm_downsample", "resample_bounding_box")
+    output = func(transform, fixed, moving, padding=padding)
+    return output
diff --git a/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box_async.py b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box_async.py
new file mode 100644
index 000000000..5ffd0d660
--- /dev/null
+++ b/packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box_async.py
@@ -0,0 +1,37 @@
+# Generated file. Do not edit.
+
+import os
+from typing import Dict, Tuple, Optional, List, Any
+
+from itkwasm import (
+    environment_dispatch,
+    TransformList,
+    Image,
+)
+
+async def resample_bounding_box_async(
+    transform: TransformList,
+    fixed: Image,
+    moving: Image,
+    padding: int = 1,
+) -> Any:
+    """Compute the padded moving-image region needed to resample the fixed image grid through a transform
+
+    :param transform: Spatial transform mapping fixed image points into moving image space
+    :type  transform: TransformList
+
+    :param fixed: Fixed image whose grid is resampled (metadata only)
+    :type  fixed: Image
+
+    :param moving: Moving image to be sampled (metadata only)
+    :type  moving: Image
+
+    :param padding: Pixels of padding added per side (default 1 for linear interpolation)
+    :type  padding: int
+
+    :return: The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)
+    :rtype:  Any
+    """
+    func = environment_dispatch("itkwasm_downsample", "resample_bounding_box_async")
+    output = await func(transform, fixed, moving, padding=padding)
+    return output
diff --git a/packages/downsample/resample-bounding-box-generate-inputs.cxx b/packages/downsample/resample-bounding-box-generate-inputs.cxx
new file mode 100644
index 000000000..3d44287fe
--- /dev/null
+++ b/packages/downsample/resample-bounding-box-generate-inputs.cxx
@@ -0,0 +1,227 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+
+// Self-contained generator of the inputs for the resample-bounding-box CTests. It writes a fixed metadata image,
+// a moving metadata image, and a transform entirely through the WebAssembly interface (.iwi / .iwt), so no
+// image-format IO is required. The --case selector chooses which self-contained input set to emit; the default
+// (2d-translation) preserves the original behavior. Each case's expected pipeline output is asserted, at double
+// precision, by the in-process resample-bounding-box-test and mirrored by the TypeScript and Python suites.
+//
+//   --case 2d-translation (default):
+//     fixed 16x16, spacing (2,2), origin (10,20)   -> physical span [10,40] x [20,50]
+//     translation (10,5)                            -> transformed span [20,50] x [25,55]
+//     moving 64x64, spacing (1,1), origin (0,0)     -> continuous index == physical
+//     => corners min (20,25) max (50,55); with --padding 1: startIndex (19,24), size (33,33)
+//
+//   --case 3d-translation:
+//     fixed 8x8x8, spacing (2,2,2), origin (10,20,30) -> physical span [10,24] x [20,34] x [30,44]
+//     translation (10,5,3)                            -> transformed span [20,34] x [25,39] x [33,47]
+//     moving 64x64x64, spacing (1,1,1), origin (0,0,0)
+//     => corners min (20,25,33) max (34,39,47); with --padding 1: startIndex (19,24,32), size (17,17,17)
+//
+//   --case 2d-rotation:
+//     fixed 20x10, spacing (1,1), origin (0,0)
+//     affine rotation (cos 0.8, sin 0.6) about center (9.5,4.5), translation (10,10) -- non-axis-aligned corners
+//     moving 64x64, spacing (1,1), origin (0,0)
+//     => corners min (9.2,5.2) max (29.8,23.8); with --padding 1: startIndex (8,4), size (24,22)
+
+#include "itkPipeline.h"
+#include "itkOutputImage.h"
+#include "itkOutputTransform.h"
+
+#include "itkImage.h"
+#include "itkTranslationTransform.h"
+#include "itkAffineTransform.h"
+
+#include <array>
+#include <string>
+
+namespace
+{
+
+// Build a metadata image (buffer allocated + zero-filled) with the given geometry and identity direction. The
+// pipeline reads only the metadata, but a real, non-empty buffer keeps the .iwi writer's data array valid.
+template <unsigned int VDimension>
+typename itk::Image<uint8_t, VDimension>::Pointer
+makeMetadataImage(const std::array<itk::SizeValueType, VDimension> & size,
+                  const std::array<double, VDimension> &             spacing,
+                  const std::array<double, VDimension> &             origin)
+{
+  using ImageType = itk::Image<uint8_t, VDimension>;
+  auto                            image = ImageType::New();
+  typename ImageType::SizeType    regionSize;
+  typename ImageType::SpacingType imageSpacing;
+  typename ImageType::PointType   imageOrigin;
+  for (unsigned int d = 0; d < VDimension; ++d)
+  {
+    regionSize[d] = size[d];
+    imageSpacing[d] = spacing[d];
+    imageOrigin[d] = origin[d];
+  }
+  image->SetRegions(typename ImageType::RegionType(regionSize));
+  image->SetSpacing(imageSpacing);
+  image->SetOrigin(imageOrigin);
+  image->Allocate();
+  image->FillBuffer(0);
+  return image;
+}
+
+int
+runTranslation2D(itk::wasm::Pipeline & pipeline)
+{
+  using ImageType = itk::Image<uint8_t, 2>;
+  using TransformType = itk::TranslationTransform<double, 2>;
+
+  itk::wasm::OutputImage<ImageType> fixedImage;
+  pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputImage<ImageType> movingImage;
+  pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputTransform<TransformType> transform;
+  pipeline.add_option("transform", transform, "Output translation transform")->required()->type_name("OUTPUT_TRANSFORM");
+
+  ITK_WASM_PARSE(pipeline);
+
+  fixedImage.Set(makeMetadataImage<2>({ 16, 16 }, { 2.0, 2.0 }, { 10.0, 20.0 }));
+  movingImage.Set(makeMetadataImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 }));
+
+  auto                            translation = TransformType::New();
+  TransformType::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  translation->SetOffset(offset);
+  transform.Set(translation);
+
+  return EXIT_SUCCESS;
+}
+
+int
+runTranslation3D(itk::wasm::Pipeline & pipeline)
+{
+  using ImageType = itk::Image<uint8_t, 3>;
+  using TransformType = itk::TranslationTransform<double, 3>;
+
+  itk::wasm::OutputImage<ImageType> fixedImage;
+  pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputImage<ImageType> movingImage;
+  pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputTransform<TransformType> transform;
+  pipeline.add_option("transform", transform, "Output translation transform")->required()->type_name("OUTPUT_TRANSFORM");
+
+  ITK_WASM_PARSE(pipeline);
+
+  fixedImage.Set(makeMetadataImage<3>({ 8, 8, 8 }, { 2.0, 2.0, 2.0 }, { 10.0, 20.0, 30.0 }));
+  movingImage.Set(makeMetadataImage<3>({ 64, 64, 64 }, { 1.0, 1.0, 1.0 }, { 0.0, 0.0, 0.0 }));
+
+  auto                            translation = TransformType::New();
+  TransformType::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  offset[2] = 3.0;
+  translation->SetOffset(offset);
+  transform.Set(translation);
+
+  return EXIT_SUCCESS;
+}
+
+int
+runRotation2D(itk::wasm::Pipeline & pipeline)
+{
+  using ImageType = itk::Image<uint8_t, 2>;
+  using TransformType = itk::AffineTransform<double, 2>;
+
+  itk::wasm::OutputImage<ImageType> fixedImage;
+  pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputImage<ImageType> movingImage;
+  pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE");
+  itk::wasm::OutputTransform<TransformType> transform;
+  pipeline.add_option("transform", transform, "Output affine rotation transform")->required()->type_name("OUTPUT_TRANSFORM");
+
+  ITK_WASM_PARSE(pipeline);
+
+  fixedImage.Set(makeMetadataImage<2>({ 20, 10 }, { 1.0, 1.0 }, { 0.0, 0.0 }));
+  movingImage.Set(makeMetadataImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 }));
+
+  // Rotation by (cos 0.8, sin 0.6) about the fixed grid center, then a translation to keep the region positive.
+  auto                       affine = TransformType::New();
+  TransformType::InputPointType center;
+  center[0] = 9.5;
+  center[1] = 4.5;
+  affine->SetCenter(center);
+  TransformType::MatrixType matrix;
+  matrix(0, 0) = 0.8;
+  matrix(0, 1) = -0.6;
+  matrix(1, 0) = 0.6;
+  matrix(1, 1) = 0.8;
+  affine->SetMatrix(matrix);
+  TransformType::OutputVectorType translation;
+  translation[0] = 10.0;
+  translation[1] = 10.0;
+  affine->SetTranslation(translation);
+  transform.Set(affine);
+
+  return EXIT_SUCCESS;
+}
+
+} // namespace
+
+int
+main(int argc, char * argv[])
+{
+  itk::wasm::Pipeline pipeline(
+    "resample-bounding-box-generate-inputs", "Generate the inputs for the resample-bounding-box tests.", argc, argv);
+
+  // Select which self-contained input set to emit. Scanned from argv directly (like the resample-bounding-box
+  // dispatch) so the case is known before the per-case output options are declared for ITK_WASM_PARSE.
+  std::string caseName = "2d-translation";
+  const auto  argCount = pipeline.get_argc();
+  const auto  argValues = pipeline.get_argv();
+  for (int ii = 1; ii < argCount; ++ii)
+  {
+    const std::string arg(argValues[ii]);
+    if ((arg == "-c" || arg == "--case") && ii + 1 < argCount)
+    {
+      caseName = argValues[ii + 1];
+    }
+    else if (arg.rfind("--case=", 0) == 0)
+    {
+      caseName = arg.substr(std::string("--case=").size());
+    }
+  }
+
+  // Declare the selector so ITK_WASM_PARSE in the case runners accepts (and ignores) the consumed --case argument.
+  std::string caseOption;
+  pipeline.add_option(
+    "-c,--case", caseOption, "Which input set to generate: 2d-translation (default), 3d-translation, 2d-rotation");
+
+  if (caseName == "2d-translation")
+  {
+    return runTranslation2D(pipeline);
+  }
+  if (caseName == "3d-translation")
+  {
+    return runTranslation3D(pipeline);
+  }
+  if (caseName == "2d-rotation")
+  {
+    return runRotation2D(pipeline);
+  }
+
+  CLI::Error err(
+    "Runtime error", "Unknown --case '" + caseName + "'. Use 2d-translation, 3d-translation, or 2d-rotation.", 1);
+  return pipeline.exit(err);
+}
diff --git a/packages/downsample/resample-bounding-box-test.cxx b/packages/downsample/resample-bounding-box-test.cxx
new file mode 100644
index 000000000..390e36195
--- /dev/null
+++ b/packages/downsample/resample-bounding-box-test.cxx
@@ -0,0 +1,507 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+
+// In-process unit test for ResampleBoundingBoxComputer. Unlike the resample-bounding-box CLI CTest (which
+// round-trips through the .iwi/.iwt WebAssembly interface and only checks the exit code), this test constructs
+// the fixed image, moving image, and transform directly and asserts the EXACT reported region for every case in
+// the dispatch matrix -- 2D translation, 3D translation, and a 2D affine rotation. Those asserted numbers are the
+// cross-surface source of truth: the TypeScript and Python suites assert the identical regions for identical
+// inputs. It also exercises: the LINEAR corners-only fast path (translation/affine report IsLinear(), so only the
+// 2^Dimension corners are sampled, yet the bound is identical to a full-boundary walk); the NONLINEAR full-boundary
+// path (a custom bulge transform where an interior edge pixel maps beyond the transformed-corner hull, so
+// corners-only would under-bound); symmetric padding; padding-independent tight corners; a degenerate zero-size
+// axis; and reuse of one instance across differing sample counts. It never touches a pixel buffer, matching the
+// pipeline's metadata-only contract.
+
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <array>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "itkImage.h"
+#include "itkTransform.h"
+#include "itkTranslationTransform.h"
+#include "itkAffineTransform.h"
+
+#include "resampleBoundingBox.h"
+
+namespace
+{
+
+int g_failures = 0;
+
+void
+checkTrue(bool condition, const std::string & message)
+{
+  if (!condition)
+  {
+    std::cerr << "FAIL: " << message << std::endl;
+    ++g_failures;
+  }
+}
+
+template <typename TActual>
+void
+printVec(const std::string & prefix, const std::vector<TActual> & values)
+{
+  std::cerr << prefix << " [";
+  for (std::size_t i = 0; i < values.size(); ++i)
+  {
+    std::cerr << (i ? ", " : "") << values[i];
+  }
+  std::cerr << "]" << std::endl;
+}
+
+// Compare an integer-like result vector (paddedStartIndex / paddedSize) against expected values exactly.
+template <typename TActual>
+void
+checkIntVec(const std::vector<TActual> & actual, const std::vector<long> & expected, const std::string & label)
+{
+  bool ok = actual.size() == expected.size();
+  for (std::size_t i = 0; ok && i < expected.size(); ++i)
+  {
+    ok = static_cast<long>(actual[i]) == expected[i];
+  }
+  if (!ok)
+  {
+    std::cerr << "FAIL: " << label << std::endl;
+    printVec("  actual  ", actual);
+    printVec("  expected", expected);
+    ++g_failures;
+  }
+}
+
+// Compare a physical-coordinate result vector (corners / paddedCorners) against expected values within a tolerance.
+void
+checkDoubleVec(const std::vector<double> & actual,
+               const std::vector<double> & expected,
+               double                      tolerance,
+               const std::string &         label)
+{
+  bool ok = actual.size() == expected.size();
+  for (std::size_t i = 0; ok && i < expected.size(); ++i)
+  {
+    ok = std::abs(actual[i] - expected[i]) <= tolerance;
+  }
+  if (!ok)
+  {
+    std::cerr << "FAIL: " << label << std::endl;
+    printVec("  actual  ", actual);
+    printVec("  expected", expected);
+    ++g_failures;
+  }
+}
+
+// Build a metadata-only uint8 image (identity direction). The buffer is allocated but never read by the computer.
+template <unsigned int VDimension>
+typename itk::Image<uint8_t, VDimension>::Pointer
+makeImage(const std::array<itk::SizeValueType, VDimension> & size,
+          const std::array<double, VDimension> &             spacing,
+          const std::array<double, VDimension> &             origin)
+{
+  using ImageType = itk::Image<uint8_t, VDimension>;
+  auto                            image = ImageType::New();
+  typename ImageType::SizeType    regionSize;
+  typename ImageType::SpacingType imageSpacing;
+  typename ImageType::PointType   imageOrigin;
+  for (unsigned int d = 0; d < VDimension; ++d)
+  {
+    regionSize[d] = size[d];
+    imageSpacing[d] = spacing[d];
+    imageOrigin[d] = origin[d];
+  }
+  image->SetRegions(typename ImageType::RegionType(regionSize));
+  image->SetSpacing(imageSpacing);
+  image->SetOrigin(imageOrigin);
+  image->Allocate();
+  image->FillBuffer(0);
+  return image;
+}
+
+itk::AffineTransform<double, 2>::Pointer
+rotationAffine()
+{
+  using AffineType = itk::AffineTransform<double, 2>;
+  auto                        affine = AffineType::New();
+  AffineType::InputPointType  center;
+  center[0] = 9.5;
+  center[1] = 4.5;
+  affine->SetCenter(center);
+  AffineType::MatrixType matrix;
+  matrix(0, 0) = 0.8;
+  matrix(0, 1) = -0.6;
+  matrix(1, 0) = 0.6;
+  matrix(1, 1) = 0.8;
+  affine->SetMatrix(matrix);
+  AffineType::OutputVectorType translation;
+  translation[0] = 10.0;
+  translation[1] = 10.0;
+  affine->SetTranslation(translation);
+  return affine;
+}
+
+// A deliberately NONLINEAR transform used to exercise the full-boundary path. It displaces each point in +x by an
+// amount that peaks at the vertical center of the fixed grid and vanishes at the top/bottom edges:
+//   out_x = x + amplitude * (1 - ((y - centerY) / halfHeight)^2),   out_y = y.
+// The four grid corners sit at the y extremes where the bump is zero, so they map to themselves; the +x extreme is
+// instead reached at the MIDDLE of the right edge -- an interior boundary pixel. A corners-only bound therefore
+// under-bounds in +x, and only the full-boundary walk captures the true extent. GetTransformCategory() reports a
+// non-Linear category, so ResampleBoundingBoxComputer (via IsLinear()) selects the boundary path.
+class EdgeBulgeTransform2D : public itk::Transform<double, 2, 2>
+{
+public:
+  ITK_DISALLOW_COPY_AND_MOVE(EdgeBulgeTransform2D);
+
+  using Self = EdgeBulgeTransform2D;
+  using Superclass = itk::Transform<double, 2, 2>;
+  using Pointer = itk::SmartPointer<Self>;
+  using ConstPointer = itk::SmartPointer<const Self>;
+  using typename Superclass::InputPointType;
+  using typename Superclass::OutputPointType;
+  using typename Superclass::ParametersType;
+  using typename Superclass::FixedParametersType;
+  using typename Superclass::JacobianType;
+  using TransformCategoryEnum = Superclass::TransformCategoryEnum;
+
+  itkNewMacro(Self);
+  itkOverrideGetNameOfClassMacro(EdgeBulgeTransform2D);
+
+  void
+  SetBulge(double centerY, double halfHeight, double amplitude)
+  {
+    m_CenterY = centerY;
+    m_HalfHeight = halfHeight;
+    m_Amplitude = amplitude;
+  }
+
+  OutputPointType
+  TransformPoint(const InputPointType & point) const override
+  {
+    const double    t = (point[1] - m_CenterY) / m_HalfHeight;
+    OutputPointType out;
+    out[0] = point[0] + m_Amplitude * (1.0 - t * t);
+    out[1] = point[1];
+    return out;
+  }
+
+  // Non-Linear: forces ResampleBoundingBoxComputer onto the full-boundary path.
+  TransformCategoryEnum
+  GetTransformCategory() const override
+  {
+    return TransformCategoryEnum::UnknownTransformCategory;
+  }
+
+  // Unused by ResampleBoundingBoxComputer (which only calls TransformPoint); stubbed to satisfy the interface.
+  void
+  SetParameters(const ParametersType &) override
+  {}
+  void
+  SetFixedParameters(const FixedParametersType &) override
+  {}
+  void
+  ComputeJacobianWithRespectToParameters(const InputPointType &, JacobianType &) const override
+  {}
+
+protected:
+  EdgeBulgeTransform2D() = default;
+  ~EdgeBulgeTransform2D() override = default;
+
+private:
+  double m_CenterY = 0.0;
+  double m_HalfHeight = 1.0;
+  double m_Amplitude = 0.0;
+};
+
+// ---- 2D translation: fixed 16x16 sp(2,2) o(10,20), moving 64x64 sp(1,1) o(0,0), translation (10,5). ----
+void
+test2DTranslation()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto fixed = makeImage<2>({ 16, 16 }, { 2.0, 2.0 }, { 10.0, 20.0 });
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+
+  auto                            translation = itk::TranslationTransform<double, 2>::New();
+  itk::TranslationTransform<double, 2>::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  translation->SetOffset(offset);
+  const TransformType * transform = translation.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  result;
+  computer.Compute(fixed, moving, transform, 1, result);
+
+  checkIntVec(result.paddedStartIndex, { 19, 24 }, "2D translation paddedStartIndex");
+  checkIntVec(result.paddedSize, { 33, 33 }, "2D translation paddedSize");
+  checkDoubleVec(result.cornersMin, { 20.0, 25.0 }, 1e-9, "2D translation corners.min");
+  checkDoubleVec(result.cornersMax, { 50.0, 55.0 }, 1e-9, "2D translation corners.max");
+  checkDoubleVec(result.paddedCornersMin, { 19.0, 24.0 }, 1e-9, "2D translation paddedCorners.min");
+  checkDoubleVec(result.paddedCornersMax, { 51.0, 56.0 }, 1e-9, "2D translation paddedCorners.max");
+  // A translation is linear, so the corners-only fast path runs: 2^2 = 4 samples, not the 60 boundary pixels,
+  // and the region above is identical to what the full-boundary walk would produce.
+  checkTrue(result.usedLinearCornerPath, "2D translation takes the linear corners-only path");
+  checkTrue(result.numberOfBoundaryPoints == 4, "2D translation samples only the 4 corners");
+}
+
+// ---- 3D translation: fixed 8^3 sp(2,2,2) o(10,20,30), moving 64^3 sp(1,1,1) o(0,0,0), translation (10,5,3). ----
+void
+test3DTranslation()
+{
+  using TransformType = itk::Transform<double, 3, 3>;
+  auto fixed = makeImage<3>({ 8, 8, 8 }, { 2.0, 2.0, 2.0 }, { 10.0, 20.0, 30.0 });
+  auto moving = makeImage<3>({ 64, 64, 64 }, { 1.0, 1.0, 1.0 }, { 0.0, 0.0, 0.0 });
+
+  auto                            translation = itk::TranslationTransform<double, 3>::New();
+  itk::TranslationTransform<double, 3>::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  offset[2] = 3.0;
+  translation->SetOffset(offset);
+  const TransformType * transform = translation.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  result;
+  computer.Compute(fixed, moving, transform, 1, result);
+
+  checkIntVec(result.paddedStartIndex, { 19, 24, 32 }, "3D translation paddedStartIndex");
+  checkIntVec(result.paddedSize, { 17, 17, 17 }, "3D translation paddedSize");
+  checkDoubleVec(result.cornersMin, { 20.0, 25.0, 33.0 }, 1e-9, "3D translation corners.min");
+  checkDoubleVec(result.cornersMax, { 34.0, 39.0, 47.0 }, 1e-9, "3D translation corners.max");
+  checkDoubleVec(result.paddedCornersMin, { 19.0, 24.0, 32.0 }, 1e-9, "3D translation paddedCorners.min");
+  checkDoubleVec(result.paddedCornersMax, { 35.0, 40.0, 48.0 }, 1e-9, "3D translation paddedCorners.max");
+  // A translation is linear, so the corners-only fast path runs: 2^3 = 8 samples, not the 296 boundary voxels,
+  // and the region above is identical to what the full-boundary walk would produce.
+  checkTrue(result.usedLinearCornerPath, "3D translation takes the linear corners-only path");
+  checkTrue(result.numberOfBoundaryPoints == 8, "3D translation samples only the 8 corners");
+
+  // padding 0 shrinks by exactly one voxel per side.
+  ResampleBoundingBoxResult tight;
+  computer.Compute(fixed, moving, transform, 0, tight);
+  checkIntVec(tight.paddedStartIndex, { 20, 25, 33 }, "3D translation padding 0 paddedStartIndex");
+  checkIntVec(tight.paddedSize, { 15, 15, 15 }, "3D translation padding 0 paddedSize");
+}
+
+// ---- 2D affine rotation: fixed 20x10 sp(1,1) o(0,0), moving 64x64 sp(1,1) o(0,0). ----
+// The rotation (cos 0.8, sin 0.6, about the grid center) maps the fixed grid to a tilted rectangle whose extremes
+// are non-axis-aligned. Because the transform is affine (linear), the tight bound is achieved at the four rotated
+// CORNERS -- itk::Transform::IsLinear() is true, so the computer takes the corners-only fast path (4 samples), and
+// asserting the reported corners equal the analytic transformed-corner extremes confirms that path tightly bounds
+// the rotated grid. The separate test2DNonlinearBoundary case exercises the full-boundary walk that is instead
+// needed when the transform is nonlinear (interior edge pixels can exceed the transformed corners).
+void
+test2DRotation()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto fixed = makeImage<2>({ 20, 10 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+
+  const auto            affine = rotationAffine();
+  const TransformType * transform = affine.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  result;
+  computer.Compute(fixed, moving, transform, 1, result);
+
+  checkDoubleVec(result.cornersMin, { 9.2, 5.2 }, 1e-9, "2D rotation corners.min (tight rotated-grid bound)");
+  checkDoubleVec(result.cornersMax, { 29.8, 23.8 }, 1e-9, "2D rotation corners.max (tight rotated-grid bound)");
+  checkIntVec(result.paddedStartIndex, { 8, 4 }, "2D rotation paddedStartIndex");
+  checkIntVec(result.paddedSize, { 24, 22 }, "2D rotation paddedSize");
+  checkDoubleVec(result.paddedCornersMin, { 8.0, 4.0 }, 1e-9, "2D rotation paddedCorners.min");
+  checkDoubleVec(result.paddedCornersMax, { 31.0, 25.0 }, 1e-9, "2D rotation paddedCorners.max");
+  // The affine rotation is linear, so only the 4 corners are sampled -- and because the affine image of the
+  // rectangle is convex, those 4 corners yield the exact same tight bound as walking all 56 boundary pixels would.
+  checkTrue(result.usedLinearCornerPath, "2D rotation takes the linear corners-only path");
+  checkTrue(result.numberOfBoundaryPoints == 4, "2D rotation samples only the 4 rotated corners");
+}
+
+// ---- 2D NONLINEAR: an interior boundary pixel maps beyond the transformed-corner hull. ----
+// Fixed 20x10 sp(1,1) o(0,0); moving 64x64 sp(1,1) o(0,0). The bulge peaks at the grid's vertical center (y=4.5)
+// with amplitude 3, vanishing at y=0 and y=9 where the corners sit. So the four corners map to themselves (x
+// extreme 19), but the middle of the right edge (nearest pixels y=4 and y=5) reaches
+// x = 19 + 3*(1 - (0.5/4.5)^2) = 21.963 -- beyond the corners. This is the case the full-boundary walk exists for:
+// a corners-only bound would stop at x=19 and the later resample would read outside the fetched block.
+void
+test2DNonlinearBoundary()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto fixed = makeImage<2>({ 20, 10 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+
+  auto bulge = EdgeBulgeTransform2D::New();
+  bulge->SetBulge(4.5, 4.5, 3.0); // centerY, halfHeight, amplitude
+  const TransformType * transform = bulge.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  result;
+  computer.Compute(fixed, moving, transform, 1, result);
+
+  // The full boundary (all 56 edge pixels of the 20x10 grid) is walked, NOT the corners-only fast path.
+  checkTrue(!result.usedLinearCornerPath, "nonlinear transform takes the full-boundary path");
+  checkTrue(result.numberOfBoundaryPoints == 56, "nonlinear transform samples all 56 boundary pixels (not 4)");
+
+  // The +x extreme comes from the middle of the right edge, well beyond the transformed corners' x = 19: proof the
+  // interior boundary pixels -- not just the corners -- drive the bound for a nonlinear transform.
+  const double cornersOnlyMaxX = 19.0; // all four corners map to themselves (bump vanishes at the y extremes)
+  checkTrue(result.cornersMax[0] > cornersOnlyMaxX + 0.5,
+            "nonlinear +x extent exceeds the corners-only bound (interior edge pixel dominates)");
+  const double expectedMaxX = 19.0 + 3.0 * (1.0 - (0.5 / 4.5) * (0.5 / 4.5));
+  checkDoubleVec(result.cornersMin, { 0.0, 0.0 }, 1e-9, "nonlinear corners.min");
+  checkDoubleVec(result.cornersMax, { expectedMaxX, 9.0 }, 1e-9, "nonlinear corners.max (right-edge middle)");
+  // x continuous-index [0, 21.963] -> floor 0 / ceil 22, padded by 1 -> start -1, size 25.
+  // y continuous-index [0, 9]      -> floor 0 / ceil 9,  padded by 1 -> start -1, size 12.
+  checkIntVec(result.paddedStartIndex, { -1, -1 }, "nonlinear paddedStartIndex");
+  checkIntVec(result.paddedSize, { 25, 12 }, "nonlinear paddedSize");
+}
+
+// ---- Padding is symmetric per side, and the unpadded (tight) corners are padding-independent. ----
+void
+testPaddingSymmetry()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto fixed = makeImage<2>({ 16, 16 }, { 2.0, 2.0 }, { 10.0, 20.0 });
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+  auto                            translation = itk::TranslationTransform<double, 2>::New();
+  itk::TranslationTransform<double, 2>::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  translation->SetOffset(offset);
+  const TransformType * transform = translation.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  base;
+  computer.Compute(fixed, moving, transform, 0, base); // tight, unpadded
+
+  for (int padding : { 1, 3, 5 })
+  {
+    ResampleBoundingBoxResult padded;
+    computer.Compute(fixed, moving, transform, padding, padded);
+    for (unsigned int d = 0; d < 2; ++d)
+    {
+      // Symmetric: the start moves out by exactly `padding` and the size grows by exactly 2 * padding.
+      checkTrue(padded.paddedStartIndex[d] == base.paddedStartIndex[d] - padding,
+                "padding start symmetry axis " + std::to_string(d) + " padding " + std::to_string(padding));
+      checkTrue(padded.paddedSize[d] == base.paddedSize[d] + 2u * static_cast<unsigned int>(padding),
+                "padding size symmetry axis " + std::to_string(d) + " padding " + std::to_string(padding));
+    }
+    // The tight corners never move with padding.
+    checkDoubleVec(padded.cornersMin, base.cornersMin, 1e-12,
+                   "corners.min padding-independent (padding " + std::to_string(padding) + ")");
+    checkDoubleVec(padded.cornersMax, base.cornersMax, 1e-12,
+                   "corners.max padding-independent (padding " + std::to_string(padding) + ")");
+  }
+}
+
+// ---- A degenerate fixed image (a zero-length axis) yields an empty region rather than crashing. ----
+void
+testDegenerateAxis()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto fixed = makeImage<2>({ 16, 0 }, { 2.0, 2.0 }, { 10.0, 20.0 }); // zero-size second axis
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+  auto                            translation = itk::TranslationTransform<double, 2>::New();
+  itk::TranslationTransform<double, 2>::OutputVectorType offset;
+  offset[0] = 10.0;
+  offset[1] = 5.0;
+  translation->SetOffset(offset);
+  const TransformType * transform = translation.GetPointer();
+
+  ResampleBoundingBoxComputer<TransformType> computer;
+  ResampleBoundingBoxResult                  result;
+  computer.Compute(fixed, moving, transform, 1, result);
+
+  checkIntVec(result.paddedSize, { 0, 0 }, "degenerate axis -> empty paddedSize");
+  checkTrue(result.numberOfBoundaryPoints == 0, "degenerate axis -> no boundary points");
+}
+
+// Value-equality of two results, used to prove instance reuse leaves no stale state.
+bool
+resultsEqual(const ResampleBoundingBoxResult & a, const ResampleBoundingBoxResult & b)
+{
+  return a.paddedStartIndex == b.paddedStartIndex && a.paddedSize == b.paddedSize &&
+         a.paddedCornersMin == b.paddedCornersMin && a.paddedCornersMax == b.paddedCornersMax &&
+         a.cornersMin == b.cornersMin && a.cornersMax == b.cornersMax &&
+         a.numberOfBoundaryPoints == b.numberOfBoundaryPoints && a.usedLinearCornerPath == b.usedLinearCornerPath;
+}
+
+// ---- Reusing one instance across calls with DIFFERENT boundary counts must not leak stale boundary points. ----
+// The result for a 16x16 fixed image must be identical whether computed on a fresh instance, or on an instance
+// previously used with a LARGER (24x24) fixed image, or with a SMALLER (4x4) one -- exercising both shrinking and
+// growing of the reused boundary-point storage. This uses the NONLINEAR bulge transform on purpose: it is the
+// full-boundary path whose sample count varies with image size (the linear path is a fixed 4 corners), so this is
+// what actually stresses the reused storage.
+void
+testInstanceReuse()
+{
+  using TransformType = itk::Transform<double, 2, 2>;
+  auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 });
+  auto bulge = EdgeBulgeTransform2D::New();
+  bulge->SetBulge(35.0, 15.0, 0.5); // arbitrary but fixed: nonlinear + deterministic across the reused calls
+  const TransformType * transform = bulge.GetPointer();
+
+  auto target = makeImage<2>({ 16, 16 }, { 2.0, 2.0 }, { 10.0, 20.0 }); // boundary count 60
+  auto bigger = makeImage<2>({ 24, 24 }, { 2.0, 2.0 }, { 10.0, 20.0 }); // boundary count 92
+  auto smaller = makeImage<2>({ 4, 4 }, { 2.0, 2.0 }, { 10.0, 20.0 });  // boundary count 12
+
+  ResampleBoundingBoxResult fresh;
+  {
+    ResampleBoundingBoxComputer<TransformType> freshComputer;
+    freshComputer.Compute(target, moving, transform, 1, fresh);
+  }
+  checkTrue(fresh.numberOfBoundaryPoints == 60, "reuse baseline boundary count (16x16 -> 60)");
+
+  // Same instance: shrink from a bigger prior call, then grow to the target.
+  ResampleBoundingBoxComputer<TransformType> reused;
+  ResampleBoundingBoxResult                  scratch;
+  reused.Compute(bigger, moving, transform, 1, scratch);
+  checkTrue(scratch.numberOfBoundaryPoints == 92, "reuse prior bigger boundary count (24x24 -> 92)");
+  ResampleBoundingBoxResult afterBigger;
+  reused.Compute(target, moving, transform, 1, afterBigger);
+  checkTrue(resultsEqual(afterBigger, fresh), "reuse after a bigger call matches fresh (no stale points)");
+
+  // Same instance: grow from a smaller prior call.
+  reused.Compute(smaller, moving, transform, 1, scratch);
+  checkTrue(scratch.numberOfBoundaryPoints == 12, "reuse prior smaller boundary count (4x4 -> 12)");
+  ResampleBoundingBoxResult afterSmaller;
+  reused.Compute(target, moving, transform, 1, afterSmaller);
+  checkTrue(resultsEqual(afterSmaller, fresh), "reuse after a smaller call matches fresh (no stale points)");
+}
+
+} // namespace
+
+int
+main()
+{
+  test2DTranslation();
+  test3DTranslation();
+  test2DRotation();
+  test2DNonlinearBoundary();
+  testPaddingSymmetry();
+  testDegenerateAxis();
+  testInstanceReuse();
+
+  if (g_failures == 0)
+  {
+    std::cout << "All resample-bounding-box unit checks passed." << std::endl;
+    return EXIT_SUCCESS;
+  }
+  std::cerr << g_failures << " resample-bounding-box unit check(s) failed." << std::endl;
+  return EXIT_FAILURE;
+}
diff --git a/packages/downsample/resample-bounding-box.cxx b/packages/downsample/resample-bounding-box.cxx
new file mode 100644
index 000000000..5e318b9da
--- /dev/null
+++ b/packages/downsample/resample-bounding-box.cxx
@@ -0,0 +1,192 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+
+// Design constraint: only image metadata (size, origin, spacing, direction) is read. The fixed and
+// moving pixel buffers are NEVER dereferenced, so both images may arrive with empty data buffers.
+//
+// Dispatch and transform reading: the pipeline supports any transform parameterization at dimensions 2, 3, and
+// 4. We dispatch on the transform DIMENSION ourselves (main() below) rather than with
+// itk::wasm::SupportInputTransformTypes because that helper's memory-IO type detection deserializes the
+// transform input -- which is a TransformList (a JSON array) -- as a single transform object, and so throws for
+// every in-memory transform. Instead, readInputTransformDimension() peeks the dimension, and readInputTransform()
+// reconstructs the transform generically into the abstract itk::Transform base (both in
+// resampleReadInputTransform.h): from the wasm memory store under --memory-io (the path the TypeScript and Python
+// bindings use), or from the filesystem otherwise (the path the C++ CTest exercises). The math is always done at
+// double precision -- lossless for float32 and float64 inputs, and robust to itk-wasm's .iwt scalar-type
+// detection, which can misreport a float64 transform as float32.
+
+#include "itkPipeline.h"
+#include "itkInputImage.h"
+#include "itkOutputTextStream.h"
+
+#include "itkImage.h"
+#include "itkTransform.h"
+
+#include "glaze/glaze.hpp"
+
+#include "resampleReadInputTransform.h"
+#include "resampleBoundingBox.h"
+
+// JSON shape of the bounding-box output. glaze serializes an aggregate's public members by name, in declaration
+// order, via compile-time reflection -- so these two structs ARE the output schema:
+//   { "paddedStartIndex": [...], "paddedSize": [...],
+//     "paddedCorners": { "min": [...], "max": [...] }, "corners": { "min": [...], "max": [...] } }
+// The tight/padded corners are grouped under min/max sub-objects; the flat vectors from ResampleBoundingBoxResult
+// are mapped into that nesting at serialization time. These types are given a NAMED namespace (external linkage)
+// on purpose: glaze's compile-time member-name reflection cannot be applied to a type with internal linkage
+// (e.g. one declared in an anonymous namespace), so the names are scoped here instead.
+namespace resampleBoundingBoxJSON
+{
+struct CornersJSON
+{
+  std::vector<double> min;
+  std::vector<double> max;
+};
+
+struct BoundingBox
+{
+  std::vector<int>          paddedStartIndex;
+  std::vector<unsigned int> paddedSize;
+  CornersJSON               paddedCorners;
+  CornersJSON               corners;
+};
+} // namespace resampleBoundingBoxJSON
+
+template <unsigned int VDimension>
+class PipelineFunctor
+{
+public:
+  int
+  operator()(itk::wasm::Pipeline & pipeline)
+  {
+    constexpr unsigned int Dimension = VDimension;
+    using ScalarType = double;
+    using TransformType = itk::Transform<ScalarType, Dimension, Dimension>;
+    using ImageType = itk::Image<uint8_t, Dimension>;
+
+    // Declaration order defines the positional CLI argument order: transform, fixed, moving, bounding-box.
+    std::string transformFileName;
+    pipeline
+      .add_option(
+        "transform", transformFileName, "Spatial transform mapping fixed image points into moving image space")
+      ->required()
+      ->type_name("INPUT_TRANSFORM");
+
+    itk::wasm::InputImage<ImageType> fixed;
+    pipeline.add_option("fixed", fixed, "Fixed image whose grid is resampled (metadata only)")
+      ->required()
+      ->type_name("INPUT_IMAGE");
+
+    itk::wasm::InputImage<ImageType> moving;
+    pipeline.add_option("moving", moving, "Moving image to be sampled (metadata only)")
+      ->required()
+      ->type_name("INPUT_IMAGE");
+
+    itk::wasm::OutputTextStream boundingBox;
+    pipeline.add_option("bounding-box", boundingBox, "The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)")
+      ->required()
+      ->type_name("OUTPUT_JSON");
+
+    int padding = 1;
+    pipeline.add_option("-p,--padding", padding, "Pixels of padding added per side (default 1 for linear interpolation)");
+
+    ITK_WASM_PARSE(pipeline);
+
+    // Read the transform generically into the abstract itk::Transform base, from the wasm memory store under
+    // --memory-io or from the filesystem otherwise. The returned smart pointer keeps the transform alive.
+    typename TransformType::ConstPointer transform;
+    ITK_WASM_CATCH_EXCEPTION(pipeline, transform = readInputTransform<Dimension>(transformFileName));
+
+    ResampleBoundingBoxComputer<TransformType> computer;
+    ResampleBoundingBoxResult                  result;
+    ITK_WASM_CATCH_EXCEPTION(pipeline, computer.Compute(fixed.Get(), moving.Get(), transform, padding, result));
+
+    // Map the computer's flat result vectors into the nested output schema and serialize with glaze. glaze
+    // emits members in declaration order, so the object key order matches the schema above. Numbers use the
+    // shortest round-trippable form (an integer-valued double like 20.0 renders as 20); the value is identical
+    // and every binding parses it numerically.
+    const resampleBoundingBoxJSON::BoundingBox output{ result.paddedStartIndex,
+                                                       result.paddedSize,
+                                                       { result.paddedCornersMin, result.paddedCornersMax },
+                                                       { result.cornersMin, result.cornersMax } };
+
+    std::string serialized;
+    const auto  writeError = glz::write_json(output, serialized);
+    if (writeError)
+    {
+      CLI::Error err("Runtime error",
+                     "Failed to serialize the bounding box JSON: " + glz::format_error(writeError, serialized),
+                     1);
+      return pipeline.exit(err);
+    }
+
+    boundingBox.Get() << serialized;
+
+    return EXIT_SUCCESS;
+  }
+};
+
+int
+main(int argc, char * argv[])
+{
+  itk::wasm::Pipeline pipeline(
+    "resample-bounding-box",
+    "Compute the padded moving-image region needed to resample the fixed image grid through a transform",
+    argc,
+    argv);
+
+  // --help / --interface-json / --version do not read any input: dispatch to a default dimension so the functor
+  // can emit help / the interface JSON (this is the path itk-wasm bindgen exercises) and exit.
+  const auto argCount = pipeline.get_argc();
+  const auto argValues = pipeline.get_argv();
+  for (int ii = 0; ii < argCount; ++ii)
+  {
+    const std::string arg(argValues[ii]);
+    if (arg == "-h" || arg == "--help" || arg == "--interface-json" || arg == "--version")
+    {
+      return PipelineFunctor<2U>()(pipeline);
+    }
+  }
+
+  // Pre-parse just the (positional) transform argument to determine its dimension, then dispatch to the
+  // dimension-specialized functor. This mirrors itk::wasm::SupportInputTransformTypes but reads the transform
+  // list correctly under --memory-io.
+  std::string transformArg;
+  auto        transformOption = pipeline.add_option("transform", transformArg, "Input transform");
+  ITK_WASM_PRE_PARSE(pipeline);
+  pipeline.remove_option(transformOption);
+
+  unsigned int dimension = 0;
+  ITK_WASM_CATCH_EXCEPTION(pipeline, dimension = readInputTransformDimension(transformArg));
+
+  switch (dimension)
+  {
+    case 2U:
+      return PipelineFunctor<2U>()(pipeline);
+    case 3U:
+      return PipelineFunctor<3U>()(pipeline);
+    case 4U:
+      return PipelineFunctor<4U>()(pipeline);
+    default:
+    {
+      CLI::Error err(
+        "Runtime error", "Unsupported transform dimension: only dimensions 2, 3, and 4 are supported.", 1);
+      return pipeline.exit(err);
+    }
+  }
+}
diff --git a/packages/downsample/resampleBoundingBox.h b/packages/downsample/resampleBoundingBox.h
new file mode 100644
index 000000000..fd2c2c37a
--- /dev/null
+++ b/packages/downsample/resampleBoundingBox.h
@@ -0,0 +1,276 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef resampleBoundingBox_h
+#define resampleBoundingBox_h
+
+#include <cstdint>
+#include <cmath>
+#include <limits>
+#include <algorithm>
+#include <vector>
+
+#include "itkImage.h"
+#include "itkContinuousIndex.h"
+
+/** Plain-data result of a resample bounding box computation.
+ *
+ * Physical corners (min/max) are stored as separate std::vector<double> members.
+ */
+struct ResampleBoundingBoxResult
+{
+  std::vector<int>          paddedStartIndex;
+  std::vector<unsigned int> paddedSize;
+  std::vector<double>       paddedCornersMin;
+  std::vector<double>       paddedCornersMax;
+  std::vector<double>       cornersMin;
+  std::vector<double>       cornersMax;
+
+  // Diagnostic only (NOT part of the serialized JSON contract): the number of fixed-image points that were
+  // sampled and transformed. On the linear fast path this is the 2^Dimension corners; otherwise it is every
+  // boundary pixel (all faces and edges). Exposed so tests can confirm which path ran and, for nonlinear
+  // transforms, that the algorithm walks the full boundary rather than only the corners.
+  std::size_t numberOfBoundaryPoints = 0;
+
+  // Diagnostic only (NOT part of the serialized JSON contract): true when the transform reported itself linear
+  // (itk::Transform::IsLinear()) and the corners-only fast path was taken; false when the full boundary was walked.
+  bool usedLinearCornerPath = false;
+};
+
+/** \class ResampleBoundingBoxComputer
+ *
+ * \brief Compute the padded moving-image region needed to resample a fixed image
+ * grid through a spatial transform.
+ *
+ * Only image metadata (size, origin, spacing, direction) is used; the fixed and
+ * moving pixel buffers are never dereferenced, so the images may arrive with empty
+ * data buffers.
+ *
+ * TTransform is expected to be the abstract itk::Transform<ScalarType, Dimension, Dimension>
+ * base instantiated by itk::wasm::SupportInputTransformTypes, so TransformPoint() and
+ * IsLinear() are dispatched polymorphically to the concrete transform.
+ *
+ * Sampling strategy: the fixed grid's bounding box in moving-image space is the min/max of the
+ * transformed fixed-grid samples. For a LINEAR (affine, rigid, translation, ...) transform the
+ * image of the fixed rectangle is convex, so its axis-aligned bound is attained at the
+ * 2^Dimension transformed corners -- the computer detects this via itk::Transform::IsLinear()
+ * and samples only the corners. For a NONLINEAR transform an interior boundary pixel can map
+ * outside the hull of the transformed corners, so the computer instead walks every boundary
+ * pixel (all faces and edges). Both paths feed the identical min/max accumulation below.
+ */
+template <typename TTransform>
+class ResampleBoundingBoxComputer
+{
+public:
+  static constexpr unsigned int Dimension = TTransform::InputSpaceDimension;
+  using ImageType = itk::Image<uint8_t, Dimension>;
+  using PointType = typename TTransform::InputPointType;
+
+  void
+  Compute(const ImageType *           fixedImage,
+          const ImageType *           movingImage,
+          const TTransform *          transform,
+          int                         padding,
+          ResampleBoundingBoxResult & result)
+  {
+    using RegionType = typename ImageType::RegionType;
+    using IndexType = typename ImageType::IndexType;
+    using SizeType = typename ImageType::SizeType;
+    using ContinuousIndexType = itk::ContinuousIndex<double, Dimension>;
+
+    const RegionType region = fixedImage->GetLargestPossibleRegion();
+    const IndexType  startIndex = region.GetIndex();
+    const SizeType   size = region.GetSize();
+
+    // Number of boundary pixels = total pixels - interior pixels. An interior pixel has every
+    // component strictly inside (0, size_d - 1), i.e. one of (size_d - 2) values per axis.
+    itk::SizeValueType totalCount = 1;
+    itk::SizeValueType interiorCount = 1;
+    for (unsigned int d = 0; d < Dimension; ++d)
+    {
+      totalCount *= size[d];
+      interiorCount *= (size[d] > 2) ? (size[d] - 2) : itk::SizeValueType(0);
+    }
+    const itk::SizeValueType boundaryCount = totalCount - interiorCount;
+
+    // A degenerate fixed region (any axis with size 0, so totalCount and boundaryCount are 0) has no boundary
+    // pixels to sample. Report an empty region instead of dereferencing the (empty) min/max accumulators below,
+    // whose sentinels would otherwise floor/ceil into garbage indices.
+    if (boundaryCount == 0)
+    {
+      result.paddedStartIndex.assign(Dimension, 0);
+      result.paddedSize.assign(Dimension, 0u);
+      result.paddedCornersMin.assign(Dimension, 0.0);
+      result.paddedCornersMax.assign(Dimension, 0.0);
+      result.cornersMin.assign(Dimension, 0.0);
+      result.cornersMax.assign(Dimension, 0.0);
+      result.numberOfBoundaryPoints = 0;
+      return;
+    }
+
+    // Reuse the member vector's storage across calls: clear() keeps the existing capacity, reserve() grows it only
+    // when this call needs more room than a previous one, and push_back() leaves the vector holding EXACTLY the
+    // points enumerated below. This is what keeps a reused instance correct when the sample count changes between
+    // calls (e.g. shrinking then growing the fixed image, or switching between the linear and boundary paths): the
+    // size always matches the current call, so no stale point from an earlier, larger call can leak into the box.
+    m_BoundaryPoints.clear();
+
+    // Linear (affine, rigid, translation, ...) transforms map the fixed rectangle to a convex region, whose
+    // axis-aligned bound is attained at the transformed corners. Detect that via itk::Transform::IsLinear()
+    // (a virtual dispatched to the concrete transform) and take the corners-only fast path -- 2^Dimension samples
+    // instead of every boundary pixel. Both paths produce the identical bounding box for a linear transform;
+    // the boundary walk is only needed to keep NONLINEAR transforms correctly bounded (an interior edge pixel can
+    // map outside the transformed-corner hull).
+    const bool linear = transform->IsLinear();
+    result.usedLinearCornerPath = linear;
+
+    if (linear)
+    {
+      // Enumerate the 2^Dimension corners with a bitmask: bit d selects the low (0) or high (size_d - 1) index
+      // component. When an axis has size 1 the low and high indices coincide, harmlessly duplicating corners.
+      const std::size_t cornerCount = std::size_t(1) << Dimension;
+      m_BoundaryPoints.reserve(cornerCount);
+      for (std::size_t mask = 0; mask < cornerCount; ++mask)
+      {
+        IndexType index;
+        for (unsigned int d = 0; d < Dimension; ++d)
+        {
+          const itk::IndexValueType last = startIndex[d] + static_cast<itk::IndexValueType>(size[d]) - 1;
+          index[d] = (mask & (std::size_t(1) << d)) ? last : startIndex[d];
+        }
+        PointType physicalPoint;
+        fixedImage->TransformIndexToPhysicalPoint(index, physicalPoint);
+        m_BoundaryPoints.push_back(physicalPoint);
+      }
+    }
+    else
+    {
+      // Enumerate every boundary pixel (at least one component equal to 0 or size_d - 1) and store
+      // its physical location. This includes all faces/edges, not just the 2^N corners, so nonlinear
+      // transforms remain correctly bounded. An odometer walks the grid, but whenever a fully interior
+      // pixel is reached the fastest axis is fast-forwarded to its last (boundary) column: this keeps
+      // enumeration proportional to the number of boundary pixels rather than the total pixel count.
+      m_BoundaryPoints.reserve(boundaryCount);
+      IndexType index = startIndex;
+      while (true)
+      {
+        bool onBoundary = false;
+        for (unsigned int d = 0; d < Dimension; ++d)
+        {
+          const itk::IndexValueType rel = index[d] - startIndex[d];
+          if (rel == 0 || rel == static_cast<itk::IndexValueType>(size[d]) - 1)
+          {
+            onBoundary = true;
+            break;
+          }
+        }
+        if (!onBoundary)
+        {
+          // Every component is interior, so the fastest axis is interior too; jump it to the last
+          // column, which is on the boundary, skipping the interior run in between.
+          index[0] = startIndex[0] + static_cast<itk::IndexValueType>(size[0]) - 1;
+        }
+
+        PointType physicalPoint;
+        fixedImage->TransformIndexToPhysicalPoint(index, physicalPoint);
+        m_BoundaryPoints.push_back(physicalPoint);
+
+        // Odometer increment, fastest axis first.
+        unsigned int d = 0;
+        for (; d < Dimension; ++d)
+        {
+          ++index[d];
+          if (index[d] < startIndex[d] + static_cast<itk::IndexValueType>(size[d]))
+          {
+            break;
+          }
+          index[d] = startIndex[d];
+        }
+        if (d == Dimension)
+        {
+          break;
+        }
+      }
+    }
+    result.numberOfBoundaryPoints = m_BoundaryPoints.size();
+
+    // Apply the transform to each boundary point, accumulating the tight physical-space min/max
+    // (in moving image physical space) and the moving-image continuous-index min/max, per axis.
+    std::vector<double> physMin(Dimension, std::numeric_limits<double>::max());
+    std::vector<double> physMax(Dimension, std::numeric_limits<double>::lowest());
+    std::vector<double> continuousIndexMin(Dimension, std::numeric_limits<double>::max());
+    std::vector<double> continuousIndexMax(Dimension, std::numeric_limits<double>::lowest());
+
+    for (const auto & boundaryPoint : m_BoundaryPoints)
+    {
+      const auto          movingPoint = transform->TransformPoint(boundaryPoint);
+      ContinuousIndexType continuousIndex;
+      movingImage->TransformPhysicalPointToContinuousIndex(movingPoint, continuousIndex);
+      for (unsigned int d = 0; d < Dimension; ++d)
+      {
+        physMin[d] = std::min(physMin[d], static_cast<double>(movingPoint[d]));
+        physMax[d] = std::max(physMax[d], static_cast<double>(movingPoint[d]));
+        continuousIndexMin[d] = std::min(continuousIndexMin[d], static_cast<double>(continuousIndex[d]));
+        continuousIndexMax[d] = std::max(continuousIndexMax[d], static_cast<double>(continuousIndex[d]));
+      }
+    }
+
+    // Convert the continuous-index bounds to an integer index region and pad outward per side.
+    result.paddedStartIndex.resize(Dimension);
+    result.paddedSize.resize(Dimension);
+    IndexType paddedStart;
+    IndexType paddedEnd;
+    for (unsigned int d = 0; d < Dimension; ++d)
+    {
+      const itk::IndexValueType startIdx = static_cast<itk::IndexValueType>(std::floor(continuousIndexMin[d]));
+      const itk::IndexValueType endIdx = static_cast<itk::IndexValueType>(std::ceil(continuousIndexMax[d]));
+      const itk::IndexValueType paddedStartValue = startIdx - padding;
+      const itk::IndexValueType paddedEndValue = endIdx + padding;
+      const itk::IndexValueType paddedSizeValue =
+        std::max<itk::IndexValueType>(0, paddedEndValue - paddedStartValue + 1);
+
+      result.paddedStartIndex[d] = static_cast<int>(paddedStartValue);
+      result.paddedSize[d] = static_cast<unsigned int>(paddedSizeValue);
+      paddedStart[d] = paddedStartValue;
+      paddedEnd[d] = paddedStartValue + paddedSizeValue - 1;
+    }
+
+    // Physical corners of the padded region come from the moving image grid.
+    PointType paddedMinPoint;
+    PointType paddedMaxPoint;
+    movingImage->TransformIndexToPhysicalPoint(paddedStart, paddedMinPoint);
+    movingImage->TransformIndexToPhysicalPoint(paddedEnd, paddedMaxPoint);
+
+    result.paddedCornersMin.resize(Dimension);
+    result.paddedCornersMax.resize(Dimension);
+    result.cornersMin.resize(Dimension);
+    result.cornersMax.resize(Dimension);
+    for (unsigned int d = 0; d < Dimension; ++d)
+    {
+      result.paddedCornersMin[d] = static_cast<double>(paddedMinPoint[d]);
+      result.paddedCornersMax[d] = static_cast<double>(paddedMaxPoint[d]);
+      result.cornersMin[d] = physMin[d];
+      result.cornersMax[d] = physMax[d];
+    }
+  }
+
+private:
+  // Reusable storage for the physical locations of the fixed image boundary pixels.
+  std::vector<typename TTransform::InputPointType> m_BoundaryPoints;
+};
+
+#endif
diff --git a/packages/downsample/resampleReadInputTransform.h b/packages/downsample/resampleReadInputTransform.h
new file mode 100644
index 000000000..10f7e3fe3
--- /dev/null
+++ b/packages/downsample/resampleReadInputTransform.h
@@ -0,0 +1,219 @@
+/*=========================================================================
+ *
+ *  Copyright NumFOCUS
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *         https://www.apache.org/licenses/LICENSE-2.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ *=========================================================================*/
+#ifndef resampleReadInputTransform_h
+#define resampleReadInputTransform_h
+
+// Read a spatial transform input into the abstract itk::Transform<double, Dim, Dim> base.
+//
+// itk-wasm's SupportInputTransformTypes dispatches the ABSTRACT base transform type so the bounding
+// box math can call TransformPoint() polymorphically over any parameterization. itk::wasm::InputTransform<T>
+// cannot be used with that base (its reconstruction filter calls T::New(), which does not compile for the
+// abstract base), so we reconstruct the concrete transform ourselves -- via the ITK object factory, exactly
+// as itkWasmTransformToTransformFilter does for composite components -- and return it upcast to the base.
+//
+// Two transport paths:
+//   * --memory-io (TypeScript / Python bindings): the transform arrives in the wasm memory store; the CLI
+//     argument is its store index. We deserialize the TransformListJSON, build the concrete transform by
+//     name, and copy the parameter arrays (whose addresses the JSON encodes) out of the store.
+//   * filesystem (native / WASI CTest): the argument is a real .iwt/.h5 path read with the transform reader.
+//
+// The math is always performed at double precision. This is lossless for float32 and float64 inputs and keeps
+// the filesystem path robust to itk-wasm's .iwt scalar-type detection, which can misreport a float64 transform
+// as float32 (reading such a transform at single precision silently drops parameters).
+
+#include <cstdlib>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "itkPipeline.h"
+#include "itkTransform.h"
+#include "itkTransformFileReader.h"
+
+#ifndef ITK_WASM_NO_MEMORY_IO
+#  include "itkWasmExports.h"
+#  include "itkTransformJSON.h"
+#  include "itktransformParameterizationString.h"
+#  include "itkTransformFactoryBase.h"
+#  include "itkObjectFactoryBase.h"
+
+#  include "glaze/glaze.hpp"
+#endif
+
+namespace
+{
+
+// Peek the input transform's dimension without fully reconstructing it, so the pipeline can dispatch to a
+// dimension-specialized functor. Reads from the wasm memory store under --memory-io, or the filesystem otherwise.
+inline unsigned int
+readInputTransformDimension(const std::string & transformArg)
+{
+  if (transformArg.empty())
+  {
+    throw std::runtime_error("The input transform argument is empty.");
+  }
+
+  if (itk::wasm::Pipeline::get_use_memory_io())
+  {
+#ifndef ITK_WASM_NO_MEMORY_IO
+    const unsigned int  index = static_cast<unsigned int>(std::stoi(transformArg));
+    const std::string & json = itk::wasm::getMemoryStoreInputJSON(0, index);
+    auto                deserialized = glz::read_json<itk::TransformListJSON>(json);
+    if (!deserialized)
+    {
+      throw std::runtime_error("Failed to parse the input transform JSON: " + glz::format_error(deserialized, json));
+    }
+    const itk::TransformListJSON transformListJSON = deserialized.value();
+    if (transformListJSON.empty())
+    {
+      throw std::runtime_error("The input transform list is empty.");
+    }
+    return transformListJSON.front().transformType.inputDimension;
+#else
+    throw std::runtime_error("Memory IO support was not compiled into this pipeline.");
+#endif
+  }
+
+  using ReaderType = itk::TransformFileReaderTemplate<double>;
+  auto reader = ReaderType::New();
+  reader->SetFileName(transformArg);
+  reader->Update();
+  const auto transformList = reader->GetTransformList();
+  if (transformList == nullptr || transformList->empty())
+  {
+    throw std::runtime_error("No transform found in the input transform file.");
+  }
+  return transformList->front()->GetInputSpaceDimension();
+}
+
+template <unsigned int VDimension>
+typename itk::Transform<double, VDimension, VDimension>::ConstPointer
+readInputTransform(const std::string & transformArg)
+{
+  using TransformType = itk::Transform<double, VDimension, VDimension>;
+
+  if (transformArg.empty())
+  {
+    throw std::runtime_error("The input transform argument is empty.");
+  }
+
+  if (itk::wasm::Pipeline::get_use_memory_io())
+  {
+#ifndef ITK_WASM_NO_MEMORY_IO
+    // The transform is in the wasm memory store; the argument is its index.
+    const unsigned int  index = static_cast<unsigned int>(std::stoi(transformArg));
+    const std::string & json = itk::wasm::getMemoryStoreInputJSON(0, index);
+
+    auto deserialized = glz::read_json<itk::TransformListJSON>(json);
+    if (!deserialized)
+    {
+      throw std::runtime_error("Failed to parse the input transform JSON: " + glz::format_error(deserialized, json));
+    }
+    const itk::TransformListJSON transformListJSON = deserialized.value();
+    if (transformListJSON.empty())
+    {
+      throw std::runtime_error("The input transform list is empty.");
+    }
+    const itk::TransformJSON & transformJSON = transformListJSON.front();
+    if (transformListJSON.size() != 1 ||
+        transformJSON.transformType.transformParameterization == itk::JSONTransformParameterizationEnum::Composite)
+    {
+      throw std::runtime_error(
+        "Only a single, non-composite transform is currently supported through the in-memory interface.");
+    }
+    if (transformJSON.transformType.inputDimension != VDimension ||
+        transformJSON.transformType.outputDimension != VDimension)
+    {
+      throw std::runtime_error("The input transform dimension does not match the pipeline dimension.");
+    }
+
+    // Construct the concrete, double-precision transform by name via the ITK object factory. The factory is
+    // populated as a side effect of GetFactory(). We always build the double variant so the math stays at
+    // double precision regardless of the input's stored precision.
+    const std::string typeString = itk::transformParameterizationString(transformJSON.transformType) +
+                                   "Transform_double_" + std::to_string(VDimension) + "_" + std::to_string(VDimension);
+    itk::TransformFactoryBase::GetFactory();
+    itk::LightObject::Pointer         instance = itk::ObjectFactoryBase::CreateInstance(typeString.c_str());
+    typename TransformType::Pointer   transform = dynamic_cast<TransformType *>(instance.GetPointer());
+    if (transform.IsNull())
+    {
+      throw std::runtime_error("Could not construct the input transform type: " + typeString);
+    }
+    instance->UnRegister(); // correct the extra reference from CreateInstance()
+
+    // The JSON encodes the parameter arrays as wasm memory addresses: "data:application/vnd.itk.address,0:<ptr>".
+    constexpr std::string::size_type addressPrefixLength = 35;
+
+    // Fixed parameters are stored at double precision (itk::Transform::FixedParametersValueType is double).
+    if (transformJSON.numberOfFixedParameters > 0)
+    {
+      const double * fixedParametersPtr = reinterpret_cast<const double *>(
+        std::strtoull(transformJSON.fixedParameters.substr(addressPrefixLength).c_str(), nullptr, 10));
+      transform->CopyInFixedParameters(fixedParametersPtr, fixedParametersPtr + transformJSON.numberOfFixedParameters);
+    }
+
+    // Parameters are stored at the transform's own precision; cast into a double buffer so the double-precision
+    // transform receives them losslessly whether the source is float32 or float64.
+    const std::size_t   numberOfParameters = static_cast<std::size_t>(transformJSON.numberOfParameters);
+    std::vector<double> parameters(numberOfParameters);
+    const std::string   parametersAddress = transformJSON.parameters.substr(addressPrefixLength);
+    if (transformJSON.transformType.parametersValueType == itk::JSONFloatTypesEnum::float32)
+    {
+      const float * source = reinterpret_cast<const float *>(std::strtoull(parametersAddress.c_str(), nullptr, 10));
+      for (std::size_t ii = 0; ii < numberOfParameters; ++ii)
+      {
+        parameters[ii] = static_cast<double>(source[ii]);
+      }
+    }
+    else
+    {
+      const double * source = reinterpret_cast<const double *>(std::strtoull(parametersAddress.c_str(), nullptr, 10));
+      for (std::size_t ii = 0; ii < numberOfParameters; ++ii)
+      {
+        parameters[ii] = source[ii];
+      }
+    }
+    transform->CopyInParameters(parameters.data(), parameters.data() + numberOfParameters);
+
+    return transform.GetPointer();
+#else
+    throw std::runtime_error("Memory IO support was not compiled into this pipeline.");
+#endif
+  }
+
+  // Filesystem path: read any parameterization generically into the base, at double precision.
+  using ReaderType = itk::TransformFileReaderTemplate<double>;
+  auto reader = ReaderType::New();
+  reader->SetFileName(transformArg);
+  reader->Update();
+  const auto transformList = reader->GetTransformList();
+  if (transformList == nullptr || transformList->empty())
+  {
+    throw std::runtime_error("No transform found in the input transform file.");
+  }
+  typename TransformType::ConstPointer transform = dynamic_cast<const TransformType *>(transformList->front().GetPointer());
+  if (transform.IsNull())
+  {
+    throw std::runtime_error("The input transform dimension or scalar type is not supported.");
+  }
+  return transform;
+}
+
+} // namespace
+
+#endif // resampleReadInputTransform_h
diff --git a/packages/downsample/typescript/package.json b/packages/downsample/typescript/package.json
index 75d06205c..67d1a277d 100644
--- a/packages/downsample/typescript/package.json
+++ b/packages/downsample/typescript/package.json
@@ -43,6 +43,7 @@
     "@itk-wasm/compare-images": "workspace:^",
     "@itk-wasm/image-io": "workspace:^",
     "@itk-wasm/mesh-io": "workspace:^",
+    "@itk-wasm/transform-io": "workspace:^",
     "@itk-wasm/demo-app": "workspace:*",
     "@playwright/test": "^1.48.2",
     "@types/node": "^20.2.5",
diff --git a/packages/downsample/typescript/src/downsample-bin-shrink-node.ts b/packages/downsample/typescript/src/downsample-bin-shrink-node.ts
index 895970c05..f24babd5b 100644
--- a/packages/downsample/typescript/src/downsample-bin-shrink-node.ts
+++ b/packages/downsample/typescript/src/downsample-bin-shrink-node.ts
@@ -46,7 +46,7 @@ async function downsampleBinShrinkNode(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -56,7 +56,7 @@ async function downsampleBinShrinkNode(
       args.push(value.toString())
     })
   }
-  if (options.informationOnly) {
+  if (typeof options.informationOnly !== "undefined") {
     options.informationOnly && args.push('--information-only')
   }
 
diff --git a/packages/downsample/typescript/src/downsample-bin-shrink.ts b/packages/downsample/typescript/src/downsample-bin-shrink.ts
index 35b5be33d..0b00b8f63 100644
--- a/packages/downsample/typescript/src/downsample-bin-shrink.ts
+++ b/packages/downsample/typescript/src/downsample-bin-shrink.ts
@@ -48,7 +48,7 @@ async function downsampleBinShrink(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -58,7 +58,7 @@ async function downsampleBinShrink(
       args.push(value.toString())
     }))
   }
-  if (options.informationOnly) {
+  if (typeof options.informationOnly !== "undefined") {
     options.informationOnly && args.push('--information-only')
   }
 
diff --git a/packages/downsample/typescript/src/downsample-label-image-node.ts b/packages/downsample/typescript/src/downsample-label-image-node.ts
index 7b2c952cb..74012be78 100644
--- a/packages/downsample/typescript/src/downsample-label-image-node.ts
+++ b/packages/downsample/typescript/src/downsample-label-image-node.ts
@@ -46,7 +46,7 @@ async function downsampleLabelImageNode(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -56,7 +56,7 @@ async function downsampleLabelImageNode(
       args.push(value.toString())
     })
   }
-  if (options.cropRadius) {
+  if (typeof options.cropRadius !== "undefined") {
     if(options.cropRadius.length < 2) {
       throw new Error('"crop-radius" option must have a length > 2')
     }
diff --git a/packages/downsample/typescript/src/downsample-label-image.ts b/packages/downsample/typescript/src/downsample-label-image.ts
index 0655c621d..c4db36dcf 100644
--- a/packages/downsample/typescript/src/downsample-label-image.ts
+++ b/packages/downsample/typescript/src/downsample-label-image.ts
@@ -48,7 +48,7 @@ async function downsampleLabelImage(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -58,7 +58,7 @@ async function downsampleLabelImage(
       args.push(value.toString())
     }))
   }
-  if (options.cropRadius) {
+  if (typeof options.cropRadius !== "undefined") {
     if(options.cropRadius.length < 2) {
       throw new Error('"crop-radius" option must have a length > 2')
     }
diff --git a/packages/downsample/typescript/src/downsample-node.ts b/packages/downsample/typescript/src/downsample-node.ts
index 8cff44c53..9bb387b09 100644
--- a/packages/downsample/typescript/src/downsample-node.ts
+++ b/packages/downsample/typescript/src/downsample-node.ts
@@ -46,7 +46,7 @@ async function downsampleNode(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -56,7 +56,7 @@ async function downsampleNode(
       args.push(value.toString())
     })
   }
-  if (options.cropRadius) {
+  if (typeof options.cropRadius !== "undefined") {
     if(options.cropRadius.length < 2) {
       throw new Error('"crop-radius" option must have a length > 2')
     }
diff --git a/packages/downsample/typescript/src/downsample.ts b/packages/downsample/typescript/src/downsample.ts
index 73249b64a..0f43cac3b 100644
--- a/packages/downsample/typescript/src/downsample.ts
+++ b/packages/downsample/typescript/src/downsample.ts
@@ -48,7 +48,7 @@ async function downsample(
 
   // Options
   args.push('--memory-io')
-  if (options.shrinkFactors) {
+  if (typeof options.shrinkFactors !== "undefined") {
     if(options.shrinkFactors.length < 2) {
       throw new Error('"shrink-factors" option must have a length > 2')
     }
@@ -58,7 +58,7 @@ async function downsample(
       args.push(value.toString())
     }))
   }
-  if (options.cropRadius) {
+  if (typeof options.cropRadius !== "undefined") {
     if(options.cropRadius.length < 2) {
       throw new Error('"crop-radius" option must have a length > 2')
     }
diff --git a/packages/downsample/typescript/src/index-common.ts b/packages/downsample/typescript/src/index-common.ts
index 5ae149f04..c888662b6 100644
--- a/packages/downsample/typescript/src/index-common.ts
+++ b/packages/downsample/typescript/src/index-common.ts
@@ -4,3 +4,4 @@ export { default as version } from './version.js'
 
 export type { Image } from 'itk-wasm'
 export type { JsonCompatible } from 'itk-wasm'
+export type { TransformList } from 'itk-wasm'
diff --git a/packages/downsample/typescript/src/index-node-only.ts b/packages/downsample/typescript/src/index-node-only.ts
index 1eb99854e..df9b02d8b 100644
--- a/packages/downsample/typescript/src/index-node-only.ts
+++ b/packages/downsample/typescript/src/index-node-only.ts
@@ -50,3 +50,13 @@ export type { GaussianKernelRadiusNodeOptions }
 
 import gaussianKernelRadiusNode from './gaussian-kernel-radius-node.js'
 export { gaussianKernelRadiusNode }
+
+
+import ResampleBoundingBoxNodeResult from './resample-bounding-box-node-result.js'
+export type { ResampleBoundingBoxNodeResult }
+
+import ResampleBoundingBoxNodeOptions from './resample-bounding-box-node-options.js'
+export type { ResampleBoundingBoxNodeOptions }
+
+import resampleBoundingBoxNode from './resample-bounding-box-node.js'
+export { resampleBoundingBoxNode }
diff --git a/packages/downsample/typescript/src/index-only.ts b/packages/downsample/typescript/src/index-only.ts
index 5e90078b2..618747498 100644
--- a/packages/downsample/typescript/src/index-only.ts
+++ b/packages/downsample/typescript/src/index-only.ts
@@ -53,3 +53,13 @@ export type { GaussianKernelRadiusOptions }
 
 import gaussianKernelRadius from './gaussian-kernel-radius.js'
 export { gaussianKernelRadius }
+
+
+import ResampleBoundingBoxResult from './resample-bounding-box-result.js'
+export type { ResampleBoundingBoxResult }
+
+import ResampleBoundingBoxOptions from './resample-bounding-box-options.js'
+export type { ResampleBoundingBoxOptions }
+
+import resampleBoundingBox from './resample-bounding-box.js'
+export { resampleBoundingBox }
diff --git a/packages/downsample/typescript/src/resample-bounding-box-node-options.ts b/packages/downsample/typescript/src/resample-bounding-box-node-options.ts
new file mode 100644
index 000000000..48e5ad455
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box-node-options.ts
@@ -0,0 +1,9 @@
+// Generated file. To retain edits, remove this comment.
+
+interface ResampleBoundingBoxNodeOptions {
+  /** Pixels of padding added per side (default 1 for linear interpolation) */
+  padding?: number
+
+}
+
+export default ResampleBoundingBoxNodeOptions
diff --git a/packages/downsample/typescript/src/resample-bounding-box-node-result.ts b/packages/downsample/typescript/src/resample-bounding-box-node-result.ts
new file mode 100644
index 000000000..2fa4192cd
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box-node-result.ts
@@ -0,0 +1,11 @@
+// Generated file. To retain edits, remove this comment.
+
+import { JsonCompatible } from 'itk-wasm'
+
+interface ResampleBoundingBoxNodeResult {
+  /** The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON) */
+  boundingBox: JsonCompatible
+
+}
+
+export default ResampleBoundingBoxNodeResult
diff --git a/packages/downsample/typescript/src/resample-bounding-box-node.ts b/packages/downsample/typescript/src/resample-bounding-box-node.ts
new file mode 100644
index 000000000..03e50d425
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box-node.ts
@@ -0,0 +1,85 @@
+// Generated file. To retain edits, remove this comment.
+
+import {
+  TransformList,
+  Image,
+  JsonCompatible,
+  InterfaceTypes,
+  PipelineOutput,
+  PipelineInput,
+  runPipelineNode
+} from 'itk-wasm'
+
+import ResampleBoundingBoxNodeOptions from './resample-bounding-box-node-options.js'
+import ResampleBoundingBoxNodeResult from './resample-bounding-box-node-result.js'
+
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+/**
+ * Compute the padded moving-image region needed to resample the fixed image grid through a transform
+ *
+ * @param {TransformList} transform - Spatial transform mapping fixed image points into moving image space
+ * @param {Image} fixed - Fixed image whose grid is resampled (metadata only)
+ * @param {Image} moving - Moving image to be sampled (metadata only)
+ * @param {ResampleBoundingBoxNodeOptions} options - options object
+ *
+ * @returns {Promise<ResampleBoundingBoxNodeResult>} - result object
+ */
+async function resampleBoundingBoxNode(
+  transform: TransformList,
+  fixed: Image,
+  moving: Image,
+  options: ResampleBoundingBoxNodeOptions = {}
+) : Promise<ResampleBoundingBoxNodeResult> {
+
+  const desiredOutputs: Array<PipelineOutput> = [
+    { type: InterfaceTypes.JsonCompatible },
+  ]
+
+  const inputs: Array<PipelineInput> = [
+    { type: InterfaceTypes.TransformList, data: transform },
+    { type: InterfaceTypes.Image, data: fixed },
+    { type: InterfaceTypes.Image, data: moving },
+  ]
+
+  const args = []
+  // Inputs
+  const transformName = '0'
+  args.push(transformName)
+
+  const fixedName = '1'
+  args.push(fixedName)
+
+  const movingName = '2'
+  args.push(movingName)
+
+  // Outputs
+  const boundingBoxName = '0'
+  args.push(boundingBoxName)
+
+  // Options
+  args.push('--memory-io')
+  if (typeof options.padding !== "undefined") {
+    args.push('--padding', options.padding.toString())
+
+  }
+
+  const pipelinePath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'pipelines', 'resample-bounding-box')
+
+  const {
+    returnValue,
+    stderr,
+    outputs
+  } = await runPipelineNode(pipelinePath, args, desiredOutputs, inputs)
+  if (returnValue !== 0 && stderr !== "") {
+    throw new Error(stderr)
+  }
+
+  const result = {
+    boundingBox: outputs[0]?.data as JsonCompatible,
+  }
+  return result
+}
+
+export default resampleBoundingBoxNode
diff --git a/packages/downsample/typescript/src/resample-bounding-box-options.ts b/packages/downsample/typescript/src/resample-bounding-box-options.ts
new file mode 100644
index 000000000..1aeb1f6ec
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box-options.ts
@@ -0,0 +1,11 @@
+// Generated file. To retain edits, remove this comment.
+
+import { WorkerPoolFunctionOption } from 'itk-wasm'
+
+interface ResampleBoundingBoxOptions extends WorkerPoolFunctionOption {
+  /** Pixels of padding added per side (default 1 for linear interpolation) */
+  padding?: number
+
+}
+
+export default ResampleBoundingBoxOptions
diff --git a/packages/downsample/typescript/src/resample-bounding-box-result.ts b/packages/downsample/typescript/src/resample-bounding-box-result.ts
new file mode 100644
index 000000000..23a809d97
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box-result.ts
@@ -0,0 +1,11 @@
+// Generated file. To retain edits, remove this comment.
+
+import { JsonCompatible, WorkerPoolFunctionResult } from 'itk-wasm'
+
+interface ResampleBoundingBoxResult extends WorkerPoolFunctionResult {
+  /** The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON) */
+  boundingBox: JsonCompatible
+
+}
+
+export default ResampleBoundingBoxResult
diff --git a/packages/downsample/typescript/src/resample-bounding-box.ts b/packages/downsample/typescript/src/resample-bounding-box.ts
new file mode 100644
index 000000000..6eafa945d
--- /dev/null
+++ b/packages/downsample/typescript/src/resample-bounding-box.ts
@@ -0,0 +1,93 @@
+// Generated file. To retain edits, remove this comment.
+
+import {
+  TransformList,
+  Image,
+  JsonCompatible,
+  InterfaceTypes,
+  PipelineOutput,
+  PipelineInput,
+  runPipeline
+} from 'itk-wasm'
+
+import ResampleBoundingBoxOptions from './resample-bounding-box-options.js'
+import ResampleBoundingBoxResult from './resample-bounding-box-result.js'
+
+import { getPipelinesBaseUrl } from './pipelines-base-url.js'
+import { getPipelineWorkerUrl } from './pipeline-worker-url.js'
+
+import { getDefaultWebWorker } from './default-web-worker.js'
+
+/**
+ * Compute the padded moving-image region needed to resample the fixed image grid through a transform
+ *
+ * @param {TransformList} transform - Spatial transform mapping fixed image points into moving image space
+ * @param {Image} fixed - Fixed image whose grid is resampled (metadata only)
+ * @param {Image} moving - Moving image to be sampled (metadata only)
+ * @param {ResampleBoundingBoxOptions} options - options object
+ *
+ * @returns {Promise<ResampleBoundingBoxResult>} - result object
+ */
+async function resampleBoundingBox(
+  transform: TransformList,
+  fixed: Image,
+  moving: Image,
+  options: ResampleBoundingBoxOptions = {}
+) : Promise<ResampleBoundingBoxResult> {
+
+  const desiredOutputs: Array<PipelineOutput> = [
+    { type: InterfaceTypes.JsonCompatible },
+  ]
+
+  const inputs: Array<PipelineInput> = [
+    { type: InterfaceTypes.TransformList, data: transform },
+    { type: InterfaceTypes.Image, data: fixed },
+    { type: InterfaceTypes.Image, data: moving },
+  ]
+
+  const args = []
+  // Inputs
+  const transformName = '0'
+  args.push(transformName)
+
+  const fixedName = '1'
+  args.push(fixedName)
+
+  const movingName = '2'
+  args.push(movingName)
+
+  // Outputs
+  const boundingBoxName = '0'
+  args.push(boundingBoxName)
+
+  // Options
+  args.push('--memory-io')
+  if (typeof options.padding !== "undefined") {
+    args.push('--padding', options.padding.toString())
+
+  }
+
+  const pipelinePath = 'resample-bounding-box'
+
+  let workerToUse = options?.webWorker
+  if (workerToUse === undefined) {
+    workerToUse = await getDefaultWebWorker()
+  }
+  const {
+    webWorker: usedWebWorker,
+    returnValue,
+    stderr,
+    outputs
+  } = await runPipeline(pipelinePath, args, desiredOutputs, inputs, { pipelineBaseUrl: getPipelinesBaseUrl(), pipelineWorkerUrl: getPipelineWorkerUrl(), webWorker: workerToUse, noCopy: options?.noCopy })
+  if (returnValue !== 0 && stderr !== "") {
+    throw new Error(stderr)
+  }
+
+  const result = {
+    webWorker: usedWebWorker as Worker,
+    boundingBox: outputs[0]?.data as JsonCompatible,
+  }
+  return result
+}
+
+export default resampleBoundingBox
diff --git a/packages/downsample/typescript/test/browser/demo-app/index.html b/packages/downsample/typescript/test/browser/demo-app/index.html
index e5a57602c..3a5e99352 100644
--- a/packages/downsample/typescript/test/browser/demo-app/index.html
+++ b/packages/downsample/typescript/test/browser/demo-app/index.html
@@ -35,6 +35,7 @@ <h3>👨‍💻 Live API Demo ✨</h3>
     <sl-tab slot="nav" panel="downsampleSigma-panel">downsampleSigma</sl-tab>
     <sl-tab slot="nav" panel="downsample-panel">downsample</sl-tab>
     <sl-tab slot="nav" panel="gaussianKernelRadius-panel">gaussianKernelRadius</sl-tab>
+    <sl-tab slot="nav" panel="resampleBoundingBox-panel">resampleBoundingBox</sl-tab>
 
 
     <sl-tab-panel name="downsampleBinShrink-panel">
@@ -242,6 +243,38 @@ <h3>👨‍💻 Live API Demo ✨</h3>
     </sl-tab-panel>
 
 
+    <sl-tab-panel name="resampleBoundingBox-panel">
+
+    <small><i>Compute the padded moving-image region needed to resample the fixed image grid through a transform</i></small><br /><br />
+
+    <div id="resampleBoundingBoxInputs"><form action="">
+      <label for="transform-file"><sl-button name="transform-file-button" variant="primary" outline onclick="this.parentElement.nextElementSibling.click()">Upload</sp-button></label><input type="file" name="transform-file" style="display: none"/>
+      <sl-tooltip content="Use the Upload button to provide the transform"><sl-details id="resampleBoundingBox-transform-details" summary="transform: Spatial transform mapping fixed image points into moving image space" disabled></sl-details></sl-tooltip>
+<br /><br />
+      <label for="fixed-file"><sl-button name="fixed-file-button" variant="primary" outline onclick="this.parentElement.nextElementSibling.click()">Upload</sp-button></label><input type="file" name="fixed-file" style="display: none"/>
+      <sl-tooltip content="Use the Upload button to provide the fixed"><itk-image-details id="resampleBoundingBox-fixed-details" summary="fixed: Fixed image whose grid is resampled (metadata only)" disabled></itk-image-details></sl-tooltip>
+<br /><br />
+      <label for="moving-file"><sl-button name="moving-file-button" variant="primary" outline onclick="this.parentElement.nextElementSibling.click()">Upload</sp-button></label><input type="file" name="moving-file" style="display: none"/>
+      <sl-tooltip content="Use the Upload button to provide the moving"><itk-image-details id="resampleBoundingBox-moving-details" summary="moving: Moving image to be sampled (metadata only)" disabled></itk-image-details></sl-tooltip>
+<br /><br />
+      <sl-input name="padding" type="number" value="1" step="1" label="padding" help-text="Pixels of padding added per side (default 1 for linear interpolation)"></sl-input>
+<br />
+    <sl-divider></sl-divider>
+      <br /><sl-tooltip content="Load example input data. This will overwrite data any existing input data."><sl-button name="loadSampleInputs" variant="default" style="display: none;">Load sample inputs</sl-button></sl-tooltip>
+      <sl-button type="button" variant="success" name="run">Run</sl-button><br /><br />
+
+    </form></div>
+    <sl-divider></sl-divider>
+
+    <div id="resampleBoundingBoxOutputs">
+      <sl-details disabled id="resampleBoundingBox-bounding-box-details" summary="boundingBox: The padded moving-image region needed to resample the fixed image grid, as a bounding box (JSON)"></sl-details>
+      <sl-button variant="neutral" outline name="bounding-box-download" disabled>Download</sl-button>
+<br /><br />
+    </div>
+
+    </sl-tab-panel>
+
+
   </sl-tab-group>
 </div>
 
diff --git a/packages/downsample/typescript/test/browser/demo-app/index.ts b/packages/downsample/typescript/test/browser/demo-app/index.ts
index 38138a7bf..39b04c5ce 100644
--- a/packages/downsample/typescript/test/browser/demo-app/index.ts
+++ b/packages/downsample/typescript/test/browser/demo-app/index.ts
@@ -22,4 +22,5 @@ import './downsample-label-image-controller.js'
 import './downsample-sigma-controller.js'
 import './downsample-controller.js'
 import './gaussian-kernel-radius-controller.js'
+import './resample-bounding-box-controller.js'
 
diff --git a/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-controller.ts b/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-controller.ts
new file mode 100644
index 000000000..941cad288
--- /dev/null
+++ b/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-controller.ts
@@ -0,0 +1,184 @@
+// Generated file. To retain edits, remove this comment.
+
+import { readImage } from '@itk-wasm/image-io'
+import { readTransform } from '@itk-wasm/transform-io'
+import * as downsample from '../../../dist/index.js'
+import resampleBoundingBoxLoadSampleInputs, { usePreRun } from "./resample-bounding-box-load-sample-inputs.js"
+
+class ResampleBoundingBoxModel {
+  inputs: Map<string, any>
+  options: Map<string, any>
+  outputs: Map<string, any>
+
+  constructor() {
+    this.inputs = new Map()
+    this.options = new Map()
+    this.outputs = new Map()
+    }
+}
+
+
+class ResampleBoundingBoxController {
+
+  constructor(loadSampleInputs) {
+    this.loadSampleInputs = loadSampleInputs
+
+    this.model = new ResampleBoundingBoxModel()
+    const model = this.model
+
+    if (loadSampleInputs) {
+      const loadSampleInputsButton = document.querySelector("#resampleBoundingBoxInputs [name=loadSampleInputs]")
+      loadSampleInputsButton.setAttribute('style', 'display: block-inline;')
+      loadSampleInputsButton.addEventListener('click', async (event) => {
+        loadSampleInputsButton.loading = true
+        await loadSampleInputs(model)
+        loadSampleInputsButton.loading = false
+      })
+    }
+
+    // ----------------------------------------------
+    // Inputs
+    const transformElement = document.querySelector('#resampleBoundingBoxInputs input[name=transform-file]')
+    transformElement.addEventListener('change', async (event) => {
+        const dataTransfer = event.dataTransfer
+        const files = event.target.files || dataTransfer.files
+
+        const { transform, webWorker } = await readTransform(files[0])
+        webWorker.terminate()
+        model.inputs.set("transform", transform)
+        const details = document.getElementById("resampleBoundingBox-transform-details")
+        details.innerHTML = `<pre>${globalThis.escapeHtml(JSON.stringify(transform, globalThis.interfaceTypeJsonReplacer, 2))}</pre>`
+        details.disabled = false
+    })
+
+    const fixedElement = document.querySelector('#resampleBoundingBoxInputs input[name=fixed-file]')
+    fixedElement.addEventListener('change', async (event) => {
+        const dataTransfer = event.dataTransfer
+        const files = event.target.files || dataTransfer.files
+
+        const { image, webWorker } = await readImage(files[0])
+        webWorker.terminate()
+        model.inputs.set("fixed", image)
+        const details = document.getElementById("resampleBoundingBox-fixed-details")
+        details.setImage(image)
+        details.disabled = false
+    })
+
+    const movingElement = document.querySelector('#resampleBoundingBoxInputs input[name=moving-file]')
+    movingElement.addEventListener('change', async (event) => {
+        const dataTransfer = event.dataTransfer
+        const files = event.target.files || dataTransfer.files
+
+        const { image, webWorker } = await readImage(files[0])
+        webWorker.terminate()
+        model.inputs.set("moving", image)
+        const details = document.getElementById("resampleBoundingBox-moving-details")
+        details.setImage(image)
+        details.disabled = false
+    })
+
+    // ----------------------------------------------
+    // Options
+    const paddingElement = document.querySelector('#resampleBoundingBoxInputs sl-input[name=padding]')
+    paddingElement.addEventListener('sl-change', (event) => {
+        model.options.set("padding", parseInt(paddingElement.value))
+    })
+
+    // ----------------------------------------------
+    // Outputs
+    const boundingBoxOutputDownload = document.querySelector('#resampleBoundingBoxOutputs sl-button[name=bounding-box-download]')
+    boundingBoxOutputDownload.addEventListener('click', async (event) => {
+        event.preventDefault()
+        event.stopPropagation()
+        if (model.outputs.has("boundingBox")) {
+            const fileName = `boundingBox.json`
+            globalThis.downloadFile(new TextEncoder().encode(JSON.stringify(model.outputs.get("boundingBox"))), fileName)
+        }
+    })
+
+    const preRun = async () => {
+      if (loadSampleInputs && usePreRun) {
+        await loadSampleInputs(model, true)
+        await this.run()
+      }
+    }
+
+    const onSelectTab = async (event) => {
+      if (event.detail.name === 'resampleBoundingBox-panel') {
+        const params = new URLSearchParams(window.location.search)
+        if (!params.has('functionName') || params.get('functionName') !== 'resampleBoundingBox') {
+          params.set('functionName', 'resampleBoundingBox')
+          const url = new URL(document.location)
+          url.search = params
+          window.history.replaceState({ functionName: 'resampleBoundingBox' }, '', url)
+          await preRun()
+        }
+      }
+    }
+
+    const tabGroup = document.querySelector('sl-tab-group')
+    tabGroup.addEventListener('sl-tab-show', onSelectTab)
+    function onInit() {
+      const params = new URLSearchParams(window.location.search)
+      if (params.has('functionName') && params.get('functionName') === 'resampleBoundingBox') {
+        tabGroup.show('resampleBoundingBox-panel')
+        preRun()
+      }
+    }
+    onInit()
+
+    const runButton = document.querySelector('#resampleBoundingBoxInputs sl-button[name="run"]')
+    runButton.addEventListener('click', async (event) => {
+      event.preventDefault()
+
+      if(!model.inputs.has('transform')) {
+        globalThis.notify("Required input not provided", "transform", "danger", "exclamation-octagon")
+        return
+      }
+      if(!model.inputs.has('fixed')) {
+        globalThis.notify("Required input not provided", "fixed", "danger", "exclamation-octagon")
+        return
+      }
+      if(!model.inputs.has('moving')) {
+        globalThis.notify("Required input not provided", "moving", "danger", "exclamation-octagon")
+        return
+      }
+
+
+      try {
+        runButton.loading = true
+
+        const t0 = performance.now()
+        const { boundingBox, } = await this.run()
+        const t1 = performance.now()
+        globalThis.notify("resampleBoundingBox successfully completed", `in ${t1 - t0} milliseconds.`, "success", "rocket-fill")
+
+        model.outputs.set("boundingBox", boundingBox)
+        boundingBoxOutputDownload.variant = "success"
+        boundingBoxOutputDownload.disabled = false
+        const boundingBoxDetails = document.getElementById("resampleBoundingBox-bounding-box-details")
+        boundingBoxDetails.innerHTML = `<pre>${globalThis.escapeHtml(JSON.stringify(boundingBox, globalThis.interfaceTypeJsonReplacer, 2))}</pre>`
+        boundingBoxDetails.disabled = false
+        const boundingBoxOutput = document.getElementById("resampleBoundingBox-bounding-box-details")
+      } catch (error) {
+        globalThis.notify("Error while running pipeline", error.toString(), "danger", "exclamation-octagon")
+        throw error
+      } finally {
+        runButton.loading = false
+      }
+    })
+  }
+
+  async run() {
+    const options = Object.fromEntries(this.model.options.entries())
+    const { boundingBox, } = await downsample.resampleBoundingBox(      this.model.inputs.get('transform'),
+      this.model.inputs.get('fixed'),
+      this.model.inputs.get('moving'),
+      Object.fromEntries(this.model.options.entries())
+    )
+
+    return { boundingBox, }
+  }
+}
+
+const resampleBoundingBoxController = new ResampleBoundingBoxController(resampleBoundingBoxLoadSampleInputs)
diff --git a/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-load-sample-inputs.ts b/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-load-sample-inputs.ts
new file mode 100644
index 000000000..7ef498d3b
--- /dev/null
+++ b/packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-load-sample-inputs.ts
@@ -0,0 +1,28 @@
+// Generated file. To retain edits, remove this comment.
+
+export default null
+// export default async function resampleBoundingBoxLoadSampleInputs (model, preRun=false) {
+
+  // Load sample inputs for the resampleBoundingBox function.
+  //
+  // This function should load sample inputs:
+  //
+  //  1) In the provided model map.
+  //  2) Into the corresponding HTML input elements if preRun is not true.
+  //
+  // Example for an input named `exampleInput`:
+
+  // const exampleInput = 5
+  // model.inputs.set("exampleInput", exampleInput)
+  // if (!preRun) {
+  //   const exampleElement = document.querySelector("#resampleBoundingBoxInputs [name=example-input]")
+  //   exampleElement.value = 5
+  // }
+
+  // return model
+// }
+
+// Use this function to run the pipeline when this tab group is select.
+// This will load the web worker if it is not already loaded, download the wasm module, and allocate memory in the wasm model.
+// Set this to `false` if sample inputs are very large or sample pipeline computation is long.
+export const usePreRun = true
diff --git a/packages/downsample/typescript/test/node/resample-bounding-box-test.js b/packages/downsample/typescript/test/node/resample-bounding-box-test.js
new file mode 100644
index 000000000..9d702a561
--- /dev/null
+++ b/packages/downsample/typescript/test/node/resample-bounding-box-test.js
@@ -0,0 +1,148 @@
+import test from 'ava'
+
+import {
+  Image,
+  ImageType,
+  IntTypes,
+  PixelTypes,
+  Transform,
+  TransformType,
+  TransformParameterizations,
+  FloatTypes
+} from 'itk-wasm'
+
+import { resampleBoundingBoxNode } from '../../dist/index-node.js'
+
+// The resample-bounding-box pipeline reads ONLY image metadata (size, spacing, origin, direction); the pixel
+// buffers are never dereferenced. These helpers therefore build "metadata-only" images whose data buffer is
+// empty -- the real payoff of the pipeline is that a caller can describe two images and a transform with a few
+// numbers and learn exactly which region of the moving image to fetch, without ever holding pixels. They are
+// dimension-generic so the same helpers cover the 2D and 3D cases; the case table below parametrizes the bodies
+// rather than copy-pasting a whole test per dimension/transform.
+
+function identityDirection (dimension) {
+  const direction = new Float64Array(dimension * dimension)
+  for (let i = 0; i < dimension; i++) {
+    direction[i * dimension + i] = 1
+  }
+  return direction
+}
+
+// A single-component, uint8 image of arbitrary dimension with the given geometry and an EMPTY pixel buffer.
+function metadataOnlyImage (size, spacing, origin) {
+  const dimension = size.length
+  const imageType = new ImageType(dimension, IntTypes.UInt8, PixelTypes.Scalar, 1)
+  const image = new Image(imageType)
+  image.size = size
+  image.spacing = spacing
+  image.origin = origin
+  image.direction = identityDirection(dimension)
+  image.data = new Uint8Array(0) // no pixels -- exercise the metadata-only contract
+  return image
+}
+
+// A single-entry TransformList holding a float64 TranslationTransform (dimension inferred from the offset).
+function translationTransform (offset) {
+  const dimension = offset.length
+  const transformType = new TransformType(TransformParameterizations.Translation, FloatTypes.Float64, dimension, dimension)
+  const transform = new Transform(transformType)
+  transform.name = 'TranslationTransform'
+  transform.numberOfFixedParameters = 0
+  transform.numberOfParameters = dimension
+  transform.fixedParameters = Float64Array.from([])
+  transform.parameters = Float64Array.from(offset)
+  return [transform]
+}
+
+// A single-entry TransformList holding a float64 AffineTransform. ITK's MatrixOffsetTransformBase packs its
+// parameters as the row-major matrix followed by the translation, and its fixed parameters as the center of
+// rotation -- so parameters = [...matrixRowMajor, ...translation], fixedParameters = center. This exactly mirrors
+// how resample-bounding-box-generate-inputs builds the transform in C++, so all three surfaces agree.
+function affineTransform (matrixRowMajor, translation, center) {
+  const dimension = translation.length
+  const transformType = new TransformType(TransformParameterizations.Affine, FloatTypes.Float64, dimension, dimension)
+  const transform = new Transform(transformType)
+  transform.name = 'AffineTransform'
+  transform.numberOfFixedParameters = center.length
+  transform.numberOfParameters = matrixRowMajor.length + translation.length
+  transform.fixedParameters = Float64Array.from(center)
+  transform.parameters = Float64Array.from([...matrixRowMajor, ...translation])
+  return [transform]
+}
+
+// Physical-coordinate arrays (corners) can carry floating-point rounding (e.g. the rotation's 5.2000000000000002),
+// so compare them within a tolerance; integer index arrays are compared exactly with deepEqual.
+function closeTo (t, actual, expected, tolerance = 1e-9) {
+  t.is(actual.length, expected.length)
+  for (let i = 0; i < expected.length; i++) {
+    t.true(Math.abs(actual[i] - expected[i]) <= tolerance, `index ${i}: ${actual[i]} vs ${expected[i]}`)
+  }
+}
+
+// Cross-surface case table. Every region here is asserted identically by the C++ unit test
+// (resample-bounding-box-test.cxx) and the Python suite, and is exercised end-to-end by the C++ CTests, so the
+// C++, TypeScript, and Python results are provably identical for the same inputs.
+//   2D translation: fixed 16x16 sp(2,2) o(10,20), translation (10,5)          -> corners [20,50] x [25,55]
+//   3D translation: fixed 8^3 sp(2,2,2) o(10,20,30), translation (10,5,3)     -> corners [20,34]x[25,39]x[33,47]
+//   2D rotation    : fixed 20x10 sp(1,1) o(0,0), affine rot(cos.8,sin.6)@(9.5,4.5)+t(10,10) -> corners [9.2,29.8]x[5.2,23.8]
+// Moving image is spacing (1,1[,1]) origin 0 throughout, so continuous index == physical coordinate.
+const cases = [
+  {
+    name: '2D translation',
+    fixed: () => metadataOnlyImage([16, 16], [2, 2], [10, 20]),
+    moving: () => metadataOnlyImage([64, 64], [1, 1], [0, 0]),
+    transform: () => translationTransform([10, 5]),
+    corners: { min: [20, 25], max: [50, 55] },
+    padding1: { start: [19, 24], size: [33, 33], paddedMin: [19, 24], paddedMax: [51, 56] },
+    padding0: { start: [20, 25], size: [31, 31], paddedMin: [20, 25], paddedMax: [50, 55] }
+  },
+  {
+    name: '3D translation',
+    fixed: () => metadataOnlyImage([8, 8, 8], [2, 2, 2], [10, 20, 30]),
+    moving: () => metadataOnlyImage([64, 64, 64], [1, 1, 1], [0, 0, 0]),
+    transform: () => translationTransform([10, 5, 3]),
+    corners: { min: [20, 25, 33], max: [34, 39, 47] },
+    padding1: { start: [19, 24, 32], size: [17, 17, 17], paddedMin: [19, 24, 32], paddedMax: [35, 40, 48] },
+    padding0: { start: [20, 25, 33], size: [15, 15, 15], paddedMin: [20, 25, 33], paddedMax: [34, 39, 47] }
+  },
+  {
+    name: '2D rotation (affine)',
+    fixed: () => metadataOnlyImage([20, 10], [1, 1], [0, 0]),
+    moving: () => metadataOnlyImage([64, 64], [1, 1], [0, 0]),
+    transform: () => affineTransform([0.8, -0.6, 0.6, 0.8], [10, 10], [9.5, 4.5]),
+    corners: { min: [9.2, 5.2], max: [29.8, 23.8] },
+    padding1: { start: [8, 4], size: [24, 22], paddedMin: [8, 4], paddedMax: [31, 25] },
+    padding0: { start: [9, 5], size: [22, 20], paddedMin: [9, 5], paddedMax: [30, 24] }
+  }
+]
+
+for (const c of cases) {
+  test(`resampleBoundingBoxNode returns the padded moving-image region for ${c.name}`, async t => {
+    // padding 1 (default): the region bounds the transformed fixed grid plus one pixel per side.
+    const { boundingBox: padded } = await resampleBoundingBoxNode(c.transform(), c.fixed(), c.moving(), { padding: 1 })
+
+    // Tight corners are padding-independent and match the analytic transformed-grid extremes.
+    closeTo(t, padded.corners.min, c.corners.min)
+    closeTo(t, padded.corners.max, c.corners.max)
+
+    t.deepEqual(padded.paddedStartIndex, c.padding1.start)
+    t.deepEqual(padded.paddedSize, c.padding1.size)
+    closeTo(t, padded.paddedCorners.min, c.padding1.paddedMin)
+    closeTo(t, padded.paddedCorners.max, c.padding1.paddedMax)
+
+    // padding 0: the empty-data images are accepted (metadata-only contract); the padded corners collapse to the
+    // integer-index bound of the tight corners (floor(min)/ceil(max), equal to the tight corners only when they
+    // already fall on grid lines, as in the translation cases -- but not the rotation); and the region is exactly
+    // one pixel smaller per side than the padding-1 region (symmetric padding).
+    const { boundingBox: tight } = await resampleBoundingBoxNode(c.transform(), c.fixed(), c.moving(), { padding: 0 })
+    t.deepEqual(tight.paddedStartIndex, c.padding0.start)
+    t.deepEqual(tight.paddedSize, c.padding0.size)
+    closeTo(t, tight.paddedCorners.min, c.padding0.paddedMin)
+    closeTo(t, tight.paddedCorners.max, c.padding0.paddedMax)
+
+    for (let axis = 0; axis < c.corners.min.length; axis++) {
+      t.is(tight.paddedStartIndex[axis], padded.paddedStartIndex[axis] + 1)
+      t.is(tight.paddedSize[axis], padded.paddedSize[axis] - 2)
+    }
+  })
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index bf3081571..7ca40a720 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -606,6 +606,9 @@ importers:
       '@itk-wasm/image-io-build':
         specifier: workspace:^
         version: link:../image-io
+      '@itk-wasm/transform-io-build':
+        specifier: workspace:^
+        version: link:../transform-io
       itk-wasm:
         specifier: workspace:^
         version: link:../core/typescript/itk-wasm
@@ -631,6 +634,9 @@ importers:
       '@itk-wasm/mesh-io':
         specifier: workspace:^
         version: link:../../mesh-io/typescript
+      '@itk-wasm/transform-io':
+        specifier: workspace:^
+        version: link:../../transform-io/typescript
       '@playwright/test':
         specifier: ^1.57.0
         version: 1.57.0