From 14e7ead0fe7557116f1b3b69e2a19eccbfd68028 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Thu, 2 Jul 2026 16:57:43 -0400 Subject: [PATCH 1/9] feat(downsample): add resample-bounding-box pipeline Add a metadata-only ITK-Wasm pipeline that computes the padded moving-image region needed to resample a fixed image grid through a spatial transform, emitting a JSON bounding box. - resampleBoundingBox.h: reusable ResampleBoundingBoxComputer (enumerates all fixed-grid boundary pixels, accumulates tight physical and moving continuous-index min/max, pads outward). Metadata only. - resample-bounding-box.cxx: thin WASM wrapper dispatching over float/double x dims 2/3/4; emits paddedStartIndex/paddedSize/ paddedCorners/corners JSON via rapidjson. - resample-bounding-box-generate-inputs.cxx: self-contained generator of fixed/moving .iwi metadata images and a translation .iwt. - CMakeLists.txt: ITKTransform/ITKTransformIO, new targets, and DEPENDS-linked CTests (generate inputs, then run the pipeline). Verified end-to-end under pnpm build:wasi / CTest (wasmtime): a (10,5) translation with padding 1 yields the hand-checked bounding box. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/downsample/CMakeLists.txt | 25 ++- .../resample-bounding-box-generate-inputs.cxx | 101 +++++++++ packages/downsample/resample-bounding-box.cxx | 182 ++++++++++++++++ packages/downsample/resampleBoundingBox.h | 206 ++++++++++++++++++ 4 files changed, 513 insertions(+), 1 deletion(-) create mode 100644 packages/downsample/resample-bounding-box-generate-inputs.cxx create mode 100644 packages/downsample/resample-bounding-box.cxx create mode 100644 packages/downsample/resampleBoundingBox.h diff --git a/packages/downsample/CMakeLists.txt b/packages/downsample/CMakeLists.txt index ad2ac5421..c9561299c 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,13 @@ 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) +foreach(pipeline downsample downsample-sigma gaussian-kernel-radius downsample-bin-shrink downsample-label-image resample-bounding-box resample-bounding-box-generate-inputs) add_executable(${pipeline} ${pipeline}.cxx) target_link_libraries(${pipeline} PUBLIC ${ITK_LIBRARIES}) target_include_directories(${pipeline} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) @@ -69,3 +71,24 @@ 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. +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) 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..0f31f9a93 --- /dev/null +++ b/packages/downsample/resample-bounding-box-generate-inputs.cxx @@ -0,0 +1,101 @@ +/*========================================================================= + * + * 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 test. It writes a fixed +// metadata image, a moving metadata image, and a translation transform entirely through the +// WebAssembly interface (.iwi / .iwt), so no image-format IO is required. +// +// With these inputs and --padding 1, resample-bounding-box should report, for the moving image: +// fixed grid: 16 x 16, spacing (2, 2), origin (10, 20) -> physical span [10,40] x [20,50] +// translation (10, 5): transformed span [20,50] x [25,55] +// moving grid: 64 x 64, spacing (1, 1), origin (0, 0) -> continuous index == physical +// => corners: min (20, 25), max (50, 55) +// => paddedStartIndex: (19, 24), paddedSize: (33, 33) +// => paddedCorners: min (19, 24), max (51, 56) + +#include "itkPipeline.h" +#include "itkOutputImage.h" +#include "itkOutputTransform.h" + +#include "itkImage.h" +#include "itkTranslationTransform.h" + +int +main(int argc, char * argv[]) +{ + itk::wasm::Pipeline pipeline( + "resample-bounding-box-generate-inputs", "Generate the inputs for the resample-bounding-box test.", argc, argv); + + using ImageType = itk::Image; + using TransformType = itk::TranslationTransform; + + itk::wasm::OutputImage fixedImage; + pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE"); + + itk::wasm::OutputImage movingImage; + pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE"); + + itk::wasm::OutputTransform transform; + pipeline.add_option("transform", transform, "Output translation transform") + ->required() + ->type_name("OUTPUT_TRANSFORM"); + + ITK_WASM_PARSE(pipeline); + + // Fixed image: 16 x 16, spacing (2, 2), non-zero origin (10, 20), identity direction. + auto fixed = ImageType::New(); + ImageType::SizeType fixedSize = { { 16, 16 } }; + ImageType::RegionType fixedRegion(fixedSize); + fixed->SetRegions(fixedRegion); + ImageType::SpacingType fixedSpacing; + fixedSpacing[0] = 2.0; + fixedSpacing[1] = 2.0; + fixed->SetSpacing(fixedSpacing); + ImageType::PointType fixedOrigin; + fixedOrigin[0] = 10.0; + fixedOrigin[1] = 20.0; + fixed->SetOrigin(fixedOrigin); + fixed->Allocate(); + fixed->FillBuffer(0); + fixedImage.Set(fixed); + + // Moving image: 64 x 64, spacing (1, 1), origin (0, 0); large enough to contain the transformed grid. + auto moving = ImageType::New(); + ImageType::SizeType movingSize = { { 64, 64 } }; + ImageType::RegionType movingRegion(movingSize); + moving->SetRegions(movingRegion); + ImageType::SpacingType movingSpacing; + movingSpacing.Fill(1.0); + moving->SetSpacing(movingSpacing); + ImageType::PointType movingOrigin; + movingOrigin.Fill(0.0); + moving->SetOrigin(movingOrigin); + moving->Allocate(); + moving->FillBuffer(0); + movingImage.Set(moving); + + // Translation transform: (10, 5). + auto translation = TransformType::New(); + TransformType::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + translation->SetOffset(offset); + transform.Set(translation); + + return EXIT_SUCCESS; +} diff --git a/packages/downsample/resample-bounding-box.cxx b/packages/downsample/resample-bounding-box.cxx new file mode 100644 index 000000000..d3e7affea --- /dev/null +++ b/packages/downsample/resample-bounding-box.cxx @@ -0,0 +1,182 @@ +/*========================================================================= + * + * 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. +// +// Transform reading: SupportInputTransformTypes dispatches with TTransform = itk::Transform, the ABSTRACT base. That base is exactly what the bounding box math needs (TransformPoint is +// virtual), but itk-wasm's InputTransform cannot be used with it: the memory-IO reconstruction calls +// T::New() / CopyInParameters, which require a concrete, instantiable T. So the transform is read +// generically -- for any parameterization -- with the ITK transform file reader into the abstract base. +// (This reads from the filesystem, which is the path exercised by the C++ CTest; wiring the in-memory +// interface for arbitrary transforms is left to a later phase.) + +#include "itkPipeline.h" +#include "itkInputImage.h" +#include "itkOutputTextStream.h" +#include "itkSupportInputTransformTypes.h" + +#include "itkImage.h" +#include "itkTransformFileReader.h" + +#include "rapidjson/document.h" +#include "rapidjson/stringbuffer.h" +#include "rapidjson/writer.h" + +#include "resampleBoundingBox.h" + +template +class PipelineFunctor +{ +public: + int + operator()(itk::wasm::Pipeline & pipeline) + { + // SupportInputTransformTypes reliably dispatches the transform DIMENSION, but the itk-wasm .iwt + // filesystem transform-type detection can misreport a float64 transform's scalar type as float32 + // (it inspects the type string of a transform read with a float-templated IO). Reading a float64 + // transform at single precision drops parameters, so always read at double precision, which is + // lossless for both float32 and float64 inputs. + constexpr unsigned int Dimension = TTransform::InputSpaceDimension; + using ScalarType = double; + using TransformType = itk::Transform; + using ImageType = itk::Image; + + // Declaration order defines the positional CLI argument order: transform, fixed, moving, output. + 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 fixed; + pipeline.add_option("fixed", fixed, "Fixed image whose grid is resampled (metadata only)") + ->required() + ->type_name("INPUT_IMAGE"); + + itk::wasm::InputImage moving; + pipeline.add_option("moving", moving, "Moving image to be sampled (metadata only)") + ->required() + ->type_name("INPUT_IMAGE"); + + itk::wasm::OutputTextStream output; + pipeline.add_option("output", output, "Output 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. + using TransformReaderType = itk::TransformFileReaderTemplate; + auto transformReader = TransformReaderType::New(); + transformReader->SetFileName(transformFileName); + ITK_WASM_CATCH_EXCEPTION(pipeline, transformReader->Update()); + + const auto transformList = transformReader->GetTransformList(); + if (transformList == nullptr || transformList->empty()) + { + CLI::Error err("Runtime error", "No transform found in the input transform file.", 1); + return pipeline.exit(err); + } + const TransformType * transform = dynamic_cast(transformList->front().GetPointer()); + if (transform == nullptr) + { + CLI::Error err("Runtime error", "The input transform dimension or scalar type is not supported.", 1); + return pipeline.exit(err); + } + + ResampleBoundingBoxComputer computer; + ResampleBoundingBoxResult result; + ITK_WASM_CATCH_EXCEPTION(pipeline, computer.Compute(fixed.Get(), moving.Get(), transform, padding, result)); + + // Serialize the result to JSON: + // { "paddedStartIndex": [...], "paddedSize": [...], + // "paddedCorners": { "min": [...], "max": [...] }, "corners": { "min": [...], "max": [...] } } + rapidjson::Document document; + document.SetObject(); + rapidjson::Document::AllocatorType & allocator = document.GetAllocator(); + + auto intArray = [&allocator](const std::vector & values) { + rapidjson::Value array(rapidjson::kArrayType); + for (const auto value : values) + { + array.PushBack(rapidjson::Value().SetInt(value), allocator); + } + return array; + }; + auto uintArray = [&allocator](const std::vector & values) { + rapidjson::Value array(rapidjson::kArrayType); + for (const auto value : values) + { + array.PushBack(rapidjson::Value().SetUint(value), allocator); + } + return array; + }; + auto doubleArray = [&allocator](const std::vector & values) { + rapidjson::Value array(rapidjson::kArrayType); + for (const auto value : values) + { + array.PushBack(rapidjson::Value().SetDouble(value), allocator); + } + return array; + }; + + rapidjson::Value paddedStartIndex = intArray(result.paddedStartIndex); + document.AddMember("paddedStartIndex", paddedStartIndex, allocator); + rapidjson::Value paddedSize = uintArray(result.paddedSize); + document.AddMember("paddedSize", paddedSize, allocator); + + rapidjson::Value paddedCorners(rapidjson::kObjectType); + rapidjson::Value paddedCornersMin = doubleArray(result.paddedCornersMin); + paddedCorners.AddMember("min", paddedCornersMin, allocator); + rapidjson::Value paddedCornersMax = doubleArray(result.paddedCornersMax); + paddedCorners.AddMember("max", paddedCornersMax, allocator); + document.AddMember("paddedCorners", paddedCorners, allocator); + + rapidjson::Value corners(rapidjson::kObjectType); + rapidjson::Value cornersMin = doubleArray(result.cornersMin); + corners.AddMember("min", cornersMin, allocator); + rapidjson::Value cornersMax = doubleArray(result.cornersMax); + corners.AddMember("max", cornersMax, allocator); + document.AddMember("corners", corners, allocator); + + rapidjson::StringBuffer stringBuffer; + rapidjson::Writer writer(stringBuffer); + document.Accept(writer); + + output.Get() << stringBuffer.GetString(); + + 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); + + return itk::wasm::SupportInputTransformTypes::Dimensions<2U, 3U, 4U>("transform", + pipeline); +} diff --git a/packages/downsample/resampleBoundingBox.h b/packages/downsample/resampleBoundingBox.h new file mode 100644 index 000000000..be820b77f --- /dev/null +++ b/packages/downsample/resampleBoundingBox.h @@ -0,0 +1,206 @@ +/*========================================================================= + * + * 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 +#include +#include +#include +#include + +#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 members. + */ +struct ResampleBoundingBoxResult +{ + std::vector paddedStartIndex; + std::vector paddedSize; + std::vector paddedCornersMin; + std::vector paddedCornersMax; + std::vector cornersMin; + std::vector cornersMax; +}; + +/** \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 + * base instantiated by itk::wasm::SupportInputTransformTypes, so TransformPoint() is + * dispatched polymorphically to the concrete transform. + */ +template +class ResampleBoundingBoxComputer +{ +public: + static constexpr unsigned int Dimension = TTransform::InputSpaceDimension; + using ImageType = itk::Image; + 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; + + 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; + + // Reuse the member vector's storage across calls. + m_BoundaryPoints.resize(boundaryCount); + + // 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. + itk::SizeValueType count = 0; + 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(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(size[0]) - 1; + } + + fixedImage->TransformIndexToPhysicalPoint(index, m_BoundaryPoints[count]); + ++count; + + // Odometer increment, fastest axis first. + unsigned int d = 0; + for (; d < Dimension; ++d) + { + ++index[d]; + if (index[d] < startIndex[d] + static_cast(size[d])) + { + break; + } + index[d] = startIndex[d]; + } + if (d == Dimension) + { + break; + } + } + + // 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 physMin(Dimension, std::numeric_limits::max()); + std::vector physMax(Dimension, std::numeric_limits::lowest()); + std::vector continuousIndexMin(Dimension, std::numeric_limits::max()); + std::vector continuousIndexMax(Dimension, std::numeric_limits::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(movingPoint[d])); + physMax[d] = std::max(physMax[d], static_cast(movingPoint[d])); + continuousIndexMin[d] = std::min(continuousIndexMin[d], static_cast(continuousIndex[d])); + continuousIndexMax[d] = std::max(continuousIndexMax[d], static_cast(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(std::floor(continuousIndexMin[d])); + const itk::IndexValueType endIdx = static_cast(std::ceil(continuousIndexMax[d])); + const itk::IndexValueType paddedStartValue = startIdx - padding; + const itk::IndexValueType paddedEndValue = endIdx + padding; + const itk::IndexValueType paddedSizeValue = + std::max(0, paddedEndValue - paddedStartValue + 1); + + result.paddedStartIndex[d] = static_cast(paddedStartValue); + result.paddedSize[d] = static_cast(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(paddedMinPoint[d]); + result.paddedCornersMax[d] = static_cast(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 m_BoundaryPoints; +}; + +#endif From e9ff0fb0fe7b7cb97768af98db624935ad5572ed Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Thu, 2 Jul 2026 17:49:44 -0400 Subject: [PATCH 2/9] feat(downsample): TypeScript bindings and Node tests for resample-bounding-box Generate and validate the TypeScript/JavaScript bindings for the resample-bounding-box pipeline, proving it is callable from Node with metadata-only images (empty pixel buffers) and a transform. - Bindings: resampleBoundingBoxNode(transform, fixed, moving, { padding }) and the browser resampleBoundingBox(...); result field renamed from the generic "output" to "boundingBox" at the source (the .cxx option name). - Exclude the test-only resample-bounding-box-generate-inputs generator from the Emscripten build (CMake `if(NOT EMSCRIPTEN)`) so bindgen does not expose it; it is still built for the WASI/native C++ CTest. - resampleReadInputTransform.h: read a spatial transform generically into the abstract itk::Transform base via the ITK object factory, from the wasm memory store under --memory-io or the filesystem otherwise (always double precision). - Dispatch on transform dimension in main() instead of SupportInputTransformTypes, whose memory-IO type detection mis-parses a TransformList (JSON array) as a single transform and throws for every in-memory transform. - bindgen: forward falsy-but-valid scalar options (e.g. padding: 0) by using a presence check instead of truthiness in function-module.js. - Node tests for padding 1 and padding 0 (region shrinks one pixel per side), both with empty-data metadata-only images; auto-discovered by the ava glob. - Browser demo controller wired into the demo-app. Verified: `pnpm test:node` passes the new tests; `pnpm test:wasi` still passes all 7 C++ CTests (no regression to the filesystem read path). Co-Authored-By: Claude Opus 4.8 (1M context) --- .../src/bindgen/typescript/function-module.js | 4 +- packages/downsample/CMakeLists.txt | 56 +++-- packages/downsample/resample-bounding-box.cxx | 103 ++++---- .../downsample/resampleReadInputTransform.h | 219 ++++++++++++++++++ .../src/downsample-bin-shrink-node.ts | 4 +- .../typescript/src/downsample-bin-shrink.ts | 4 +- .../src/downsample-label-image-node.ts | 4 +- .../typescript/src/downsample-label-image.ts | 4 +- .../typescript/src/downsample-node.ts | 4 +- .../downsample/typescript/src/downsample.ts | 4 +- .../downsample/typescript/src/index-common.ts | 1 + .../typescript/src/index-node-only.ts | 10 + .../downsample/typescript/src/index-only.ts | 10 + .../src/resample-bounding-box-node-options.ts | 9 + .../src/resample-bounding-box-node-result.ts | 11 + .../src/resample-bounding-box-node.ts | 85 +++++++ .../src/resample-bounding-box-options.ts | 11 + .../src/resample-bounding-box-result.ts | 11 + .../typescript/src/resample-bounding-box.ts | 93 ++++++++ .../test/browser/demo-app/index.html | 33 +++ .../typescript/test/browser/demo-app/index.ts | 1 + .../resample-bounding-box-controller.ts | 184 +++++++++++++++ ...esample-bounding-box-load-sample-inputs.ts | 28 +++ .../test/node/resample-bounding-box-test.js | 95 ++++++++ 24 files changed, 918 insertions(+), 70 deletions(-) create mode 100644 packages/downsample/resampleReadInputTransform.h create mode 100644 packages/downsample/typescript/src/resample-bounding-box-node-options.ts create mode 100644 packages/downsample/typescript/src/resample-bounding-box-node-result.ts create mode 100644 packages/downsample/typescript/src/resample-bounding-box-node.ts create mode 100644 packages/downsample/typescript/src/resample-bounding-box-options.ts create mode 100644 packages/downsample/typescript/src/resample-bounding-box-result.ts create mode 100644 packages/downsample/typescript/src/resample-bounding-box.ts create mode 100644 packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-controller.ts create mode 100644 packages/downsample/typescript/test/browser/demo-app/resample-bounding-box-load-sample-inputs.ts create mode 100644 packages/downsample/typescript/test/node/resample-bounding-box-test.js 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/downsample/CMakeLists.txt b/packages/downsample/CMakeLists.txt index c9561299c..76461d8d3 100644 --- a/packages/downsample/CMakeLists.txt +++ b/packages/downsample/CMakeLists.txt @@ -28,7 +28,25 @@ find_package(ITK REQUIRED ) include(${ITK_USE_FILE}) -foreach(pipeline downsample downsample-sigma gaussian-kernel-radius downsample-bin-shrink downsample-label-image resample-bounding-box resample-bounding-box-generate-inputs) +set(pipelines + downsample + downsample-sigma + gaussian-kernel-radius + downsample-bin-shrink + downsample-label-image + resample-bounding-box + ) + +# resample-bounding-box-generate-inputs only fabricates the self-contained inputs (fixed image, moving +# image, transform) for the resample-bounding-box C++ CTest, which runs under the WASI/native toolchains. +# It is deliberately NOT built for Emscripten: itk-wasm bindgen scans the Emscripten build for pipeline +# .wasm files, so building it there would expose it as a public browser/Node binding. The real, public +# pipeline is resample-bounding-box. +if(NOT EMSCRIPTEN) + list(APPEND pipelines resample-bounding-box-generate-inputs) +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}) @@ -74,21 +92,25 @@ add_test(NAME downsample-label-image # 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. -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 - ) +# 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 - ) + 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) + set_tests_properties(resample-bounding-box PROPERTIES DEPENDS resample-bounding-box-generate-inputs) +endif() diff --git a/packages/downsample/resample-bounding-box.cxx b/packages/downsample/resample-bounding-box.cxx index d3e7affea..e3f4b7905 100644 --- a/packages/downsample/resample-bounding-box.cxx +++ b/packages/downsample/resample-bounding-box.cxx @@ -19,46 +19,44 @@ // 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. // -// Transform reading: SupportInputTransformTypes dispatches with TTransform = itk::Transform, the ABSTRACT base. That base is exactly what the bounding box math needs (TransformPoint is -// virtual), but itk-wasm's InputTransform cannot be used with it: the memory-IO reconstruction calls -// T::New() / CopyInParameters, which require a concrete, instantiable T. So the transform is read -// generically -- for any parameterization -- with the ITK transform file reader into the abstract base. -// (This reads from the filesystem, which is the path exercised by the C++ CTest; wiring the in-memory -// interface for arbitrary transforms is left to a later phase.) +// 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 "itkSupportInputTransformTypes.h" #include "itkImage.h" -#include "itkTransformFileReader.h" +#include "itkTransform.h" #include "rapidjson/document.h" #include "rapidjson/stringbuffer.h" #include "rapidjson/writer.h" +#include "resampleReadInputTransform.h" #include "resampleBoundingBox.h" -template +template class PipelineFunctor { public: int operator()(itk::wasm::Pipeline & pipeline) { - // SupportInputTransformTypes reliably dispatches the transform DIMENSION, but the itk-wasm .iwt - // filesystem transform-type detection can misreport a float64 transform's scalar type as float32 - // (it inspects the type string of a transform read with a float-templated IO). Reading a float64 - // transform at single precision drops parameters, so always read at double precision, which is - // lossless for both float32 and float64 inputs. - constexpr unsigned int Dimension = TTransform::InputSpaceDimension; + constexpr unsigned int Dimension = VDimension; using ScalarType = double; using TransformType = itk::Transform; using ImageType = itk::Image; - // Declaration order defines the positional CLI argument order: transform, fixed, moving, output. + // Declaration order defines the positional CLI argument order: transform, fixed, moving, bounding-box. std::string transformFileName; pipeline .add_option( @@ -76,32 +74,20 @@ class PipelineFunctor ->required() ->type_name("INPUT_IMAGE"); - itk::wasm::OutputTextStream output; - pipeline.add_option("output", output, "Output bounding box JSON")->required()->type_name("OUTPUT_JSON"); + 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. - using TransformReaderType = itk::TransformFileReaderTemplate; - auto transformReader = TransformReaderType::New(); - transformReader->SetFileName(transformFileName); - ITK_WASM_CATCH_EXCEPTION(pipeline, transformReader->Update()); - - const auto transformList = transformReader->GetTransformList(); - if (transformList == nullptr || transformList->empty()) - { - CLI::Error err("Runtime error", "No transform found in the input transform file.", 1); - return pipeline.exit(err); - } - const TransformType * transform = dynamic_cast(transformList->front().GetPointer()); - if (transform == nullptr) - { - CLI::Error err("Runtime error", "The input transform dimension or scalar type is not supported.", 1); - return pipeline.exit(err); - } + // 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(transformFileName)); ResampleBoundingBoxComputer computer; ResampleBoundingBoxResult result; @@ -162,7 +148,7 @@ class PipelineFunctor rapidjson::Writer writer(stringBuffer); document.Accept(writer); - output.Get() << stringBuffer.GetString(); + boundingBox.Get() << stringBuffer.GetString(); return EXIT_SUCCESS; } @@ -177,6 +163,43 @@ main(int argc, char * argv[]) argc, argv); - return itk::wasm::SupportInputTransformTypes::Dimensions<2U, 3U, 4U>("transform", - pipeline); + // --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/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 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 +// 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 +#include +#include +#include + +#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(std::stoi(transformArg)); + const std::string & json = itk::wasm::getMemoryStoreInputJSON(0, index); + auto deserialized = glz::read_json(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; + 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 +typename itk::Transform::ConstPointer +readInputTransform(const std::string & transformArg) +{ + using TransformType = itk::Transform; + + 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(std::stoi(transformArg)); + const std::string & json = itk::wasm::getMemoryStoreInputJSON(0, index); + + auto deserialized = glz::read_json(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(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:". + 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( + 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(transformJSON.numberOfParameters); + std::vector parameters(numberOfParameters); + const std::string parametersAddress = transformJSON.parameters.substr(addressPrefixLength); + if (transformJSON.transformType.parametersValueType == itk::JSONFloatTypesEnum::float32) + { + const float * source = reinterpret_cast(std::strtoull(parametersAddress.c_str(), nullptr, 10)); + for (std::size_t ii = 0; ii < numberOfParameters; ++ii) + { + parameters[ii] = static_cast(source[ii]); + } + } + else + { + const double * source = reinterpret_cast(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; + 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(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/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} - result object + */ +async function resampleBoundingBoxNode( + transform: TransformList, + fixed: Image, + moving: Image, + options: ResampleBoundingBoxNodeOptions = {} +) : Promise { + + const desiredOutputs: Array = [ + { type: InterfaceTypes.JsonCompatible }, + ] + + const inputs: Array = [ + { 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} - result object + */ +async function resampleBoundingBox( + transform: TransformList, + fixed: Image, + moving: Image, + options: ResampleBoundingBoxOptions = {} +) : Promise { + + const desiredOutputs: Array = [ + { type: InterfaceTypes.JsonCompatible }, + ] + + const inputs: Array = [ + { 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 @@

👨‍💻 Live API Demo ✨

downsampleSigma downsample gaussianKernelRadius + resampleBoundingBox @@ -242,6 +243,38 @@

👨‍💻 Live API Demo ✨

 + + + Compute the padded moving-image region needed to resample the fixed image grid through a transform

+ +
+ + +

+ + +

+ + +

+ +
+ +
Load sample inputs + Run

+ +
+ + +
+ + Download +

+
+ + + + 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 + options: Map + outputs: Map + + 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 = `
${globalThis.escapeHtml(JSON.stringify(transform, globalThis.interfaceTypeJsonReplacer, 2))}
` + 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 = `
${globalThis.escapeHtml(JSON.stringify(boundingBox, globalThis.interfaceTypeJsonReplacer, 2))}
` + 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..2a523c46a --- /dev/null +++ b/packages/downsample/typescript/test/node/resample-bounding-box-test.js @@ -0,0 +1,95 @@ +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. + +// A 2D, single-component, uint8 image with the given geometry and an EMPTY pixel buffer. +function metadataOnlyImage (size, spacing, origin) { + const imageType = new ImageType(2, IntTypes.UInt8, PixelTypes.Scalar, 1) + const image = new Image(imageType) + image.size = size + image.spacing = spacing + image.origin = origin + image.direction = Float64Array.from([1, 0, 0, 1]) // identity + image.data = new Uint8Array(0) // no pixels -- exercise the metadata-only contract + return image +} + +// A single-entry TransformList holding a 2D, float64 TranslationTransform with the given offset. +function translationTransform (offset) { + const transformType = new TransformType( + TransformParameterizations.Translation, + FloatTypes.Float64, + 2, + 2 + ) + const transform = new Transform(transformType) + transform.name = 'TranslationTransform' + transform.numberOfFixedParameters = 0 + transform.numberOfParameters = 2 + transform.fixedParameters = Float64Array.from([]) + transform.parameters = Float64Array.from(offset) + return [transform] +} + +// Shared geometry (matches the self-contained C++ CTest inputs, whose output is independently verified): +// fixed : 16x16, spacing (2,2), origin (10,20) -> physical grid [10,40] x [20,50] +// moving: 64x64, spacing (1,1), origin (0, 0) -> continuous index == physical coordinate +// transform: translation (10,5) -> fixed grid maps to [20,50] x [25,55] +// The tight (unpadded) moving-image region is therefore start (20,25), inclusive-end (50,55). +const fixedImage = () => metadataOnlyImage([16, 16], [2, 2], [10, 20]) +const movingImage = () => metadataOnlyImage([64, 64], [1, 1], [0, 0]) +const transform = () => translationTransform([10, 5]) + +test('resampleBoundingBoxNode returns the padded region for a translation (padding 1)', async t => { + const { boundingBox } = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { + padding: 1 + }) + + // Tight corners are padding-independent: the translated fixed grid, [20,50] x [25,55]. + t.deepEqual(boundingBox.corners.min, [20, 25]) + t.deepEqual(boundingBox.corners.max, [50, 55]) + + // With one pixel of padding per side the integer region grows outward by one on every side. + t.deepEqual(boundingBox.paddedStartIndex, [19, 24]) + t.deepEqual(boundingBox.paddedSize, [33, 33]) // (50-20) + 1 tight, +2 for padding => 33 + + // Padded corners are the physical location of the padded start and inclusive-end indices in the moving image. + t.deepEqual(boundingBox.paddedCorners.min, [19, 24]) + t.deepEqual(boundingBox.paddedCorners.max, [51, 56]) +}) + +test('resampleBoundingBoxNode with padding 0 shrinks by exactly one pixel per side and accepts empty pixel data', async t => { + const padded = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { padding: 1 }) + const tight = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { padding: 0 }) + + // The empty-data moving image was accepted without error (metadata-only contract holds). + t.deepEqual(tight.boundingBox.paddedStartIndex, [20, 25]) + t.deepEqual(tight.boundingBox.paddedSize, [31, 31]) + + // With no padding the region is exactly the tight corners. + t.deepEqual(tight.boundingBox.paddedCorners.min, tight.boundingBox.corners.min) + t.deepEqual(tight.boundingBox.paddedCorners.max, tight.boundingBox.corners.max) + + // Compared with the default (padding 1), padding 0 shrinks the region by exactly one pixel on every side: + // the start index moves in by one and the size shrinks by two (one per side) on each axis. + for (let axis = 0; axis < 2; axis++) { + t.is(tight.boundingBox.paddedStartIndex[axis], padded.boundingBox.paddedStartIndex[axis] + 1) + t.is(tight.boundingBox.paddedSize[axis], padded.boundingBox.paddedSize[axis] - 2) + } +}) From 8ac55554e5ea0bbd893e6e92d279c226345de0e3 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Thu, 2 Jul 2026 18:23:43 -0400 Subject: [PATCH 3/9] feat(downsample): Python bindings and WASI pytest for resample-bounding-box Generate the itkwasm-downsample Python bindings (wasi, emscripten, dispatch) for the resample-bounding-box pipeline and add a WASI pytest validating the padded moving-image region for a 2D translation with metadata-only images. Framework changes: - cli/bindgen.js: honor an opt-in `itk-wasm.bindgen-exclude` list so build-only helper executables (the resample-bounding-box-generate-inputs CTest fixture, which must be built under WASI) are not emitted as public language bindings. - python bindgen (wasi/emscripten function modules): forward numeric scalar options with a presence check (`is not None`) instead of truthiness, so a valid `padding=0` is no longer dropped to the C++ default of 1 (the Python analogue of the Phase-02 TypeScript falsy-0 fix). pnpm test:python:wasi -> 13 passed (2 new: padding=1 exact region, padding=0 shrinks one pixel per side). Co-Authored-By: Claude Opus 4.8 (1M context) --- .../emscripten/emscripten-function-module.js | 11 +- .../python/wasi/wasi-function-module.js | 7 +- .../typescript/itk-wasm/src/cli/bindgen.js | 22 +++ packages/downsample/package.json | 5 +- .../itkwasm_downsample_emscripten/__init__.py | 1 + .../gaussian_kernel_radius_async.py | 4 +- .../js_package.py | 2 +- .../resample_bounding_box_async.py | 65 +++++++++ .../itkwasm_downsample_wasi/__init__.py | 1 + .../resample_bounding_box.py | 77 +++++++++++ .../tests/test_resample_bounding_box.py | 130 ++++++++++++++++++ .../itkwasm_downsample/__init__.py | 2 + .../resample_bounding_box.py | 37 +++++ .../resample_bounding_box_async.py | 37 +++++ 14 files changed, 395 insertions(+), 6 deletions(-) create mode 100644 packages/downsample/python/itkwasm-downsample-emscripten/itkwasm_downsample_emscripten/resample_bounding_box_async.py create mode 100644 packages/downsample/python/itkwasm-downsample-wasi/itkwasm_downsample_wasi/resample_bounding_box.py create mode 100644 packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py create mode 100644 packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box.py create mode 100644 packages/downsample/python/itkwasm-downsample/itkwasm_downsample/resample_bounding_box_async.py 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/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/package.json b/packages/downsample/package.json index 77e47895c..97a581eab 100644 --- a/packages/downsample/package.json +++ b/packages/downsample/package.json @@ -14,7 +14,10 @@ "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" + ] }, "scripts": { "build": "pnpm build:gen:typescript && pnpm build:gen:python", 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..e3dec4025 --- /dev/null +++ b/packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py @@ -0,0 +1,130 @@ +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. + + +def metadata_only_image(size, spacing, origin): + """A 2D, single-component, uint8 Image with the given geometry and an EMPTY pixel buffer.""" + image_type = ImageType( + dimension=2, + componentType=IntTypes.UInt8, + pixelType=PixelTypes.Scalar, + components=1, + ) + return Image( + imageType=image_type, + origin=origin, + spacing=spacing, + direction=np.eye(2, 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 2D, float64 TranslationTransform with the given 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. + """ + transform_type = TransformType( + transformParameterization=TransformParameterizations.Translation, + parametersValueType=FloatTypes.Float64, + inputDimension=2, + outputDimension=2, + ) + transform = Transform( + transformType=transform_type, + numberOfFixedParameters=0, + numberOfParameters=2, + fixedParameters=np.empty((0,), dtype=np.float64), + parameters=np.asarray(offset, dtype=np.float64), + name="TranslationTransform", + ) + return [transform] + + +# Shared geometry (matches the self-contained C++ CTest inputs, whose output is independently verified, and the +# TypeScript node test): +# fixed : 16x16, spacing (2,2), origin (10,20) -> physical grid [10,40] x [20,50] +# moving: 64x64, spacing (1,1), origin (0, 0) -> continuous index == physical coordinate +# transform: translation (10,5) -> fixed grid maps to [20,50] x [25,55] +# The tight (unpadded) moving-image region is therefore start (20,25), inclusive-end (50,55). +def fixed_image(): + return metadata_only_image([16, 16], [2, 2], [10, 20]) + + +def moving_image(): + return metadata_only_image([64, 64], [1, 1], [0, 0]) + + +def transform(): + return translation_transform([10, 5]) + + +def test_resample_bounding_box(): + """With one pixel of padding per side, the reported region bounds the translated fixed grid plus one pixel.""" + result = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=1) + + # Tight corners are padding-independent: the translated fixed grid, [20,50] x [25,55]. + assert result["corners"]["min"] == pytest.approx([20, 25]) + assert result["corners"]["max"] == pytest.approx([50, 55]) + + # With one pixel of padding per side the integer region grows outward by one on every side. + assert result["paddedStartIndex"] == [19, 24] + assert result["paddedSize"] == [33, 33] # (50-20) + 1 tight, +2 for padding => 33 + + # Padded corners are the physical location of the padded start and inclusive-end indices in the moving image. + assert result["paddedCorners"]["min"] == pytest.approx([19, 24]) + assert result["paddedCorners"]["max"] == pytest.approx([51, 56]) + + # Persist the result next to the other Python test outputs for inspection. + with open(test_output_path / "resample-bounding-box.json", "w") as fp: + json.dump(result, fp) + + +def test_resample_bounding_box_padding_zero_shrinks_by_one_per_side(): + """padding=0 shrinks the region by exactly one pixel per side and accepts an empty-data moving image. + + Cross-checks the C++, TypeScript, and Python results against one another: the padding=0 region here is the + same one asserted in the TypeScript test, and the shrink relationship mirrors it exactly. + """ + padded = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=1) + tight = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=0) + + # The empty-data moving image was accepted without error (the metadata-only contract holds), and padding=0 + # was actually forwarded (a falsy 0 must not fall back to the C++ default of 1). + assert tight["paddedStartIndex"] == [20, 25] + assert tight["paddedSize"] == [31, 31] + + # With no padding the integer region is exactly the tight corners. + assert tight["paddedCorners"]["min"] == pytest.approx(tight["corners"]["min"]) + assert tight["paddedCorners"]["max"] == pytest.approx(tight["corners"]["max"]) + + # Compared with the default (padding 1), padding 0 shrinks the region by exactly one pixel on every side: + # the start index moves in by one and the size shrinks by two (one per side) on each axis. + for axis in range(2): + assert tight["paddedStartIndex"][axis] == padded["paddedStartIndex"][axis] + 1 + assert tight["paddedSize"][axis] == padded["paddedSize"][axis] - 2 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 From c20b08986734893bfa3343d86484296dfff6435c Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Thu, 2 Jul 2026 19:00:19 -0400 Subject: [PATCH 4/9] test(downsample): 3D + affine-rotation coverage, edge-case hardening Phase 04 of the resample-bounding-box pipeline: multi-dimension coverage, robustness, and a documentation artifact. C++ 12/12 CTests, Node 8/8, and Python wasi 14/14 all pass, with identical regions across the three surfaces. resampleBoundingBox.h (hardening): - Guard a degenerate fixed image (any zero-length axis): report an empty region instead of floor/ceil-ing sentinel min/max into garbage indices. - Make boundary-point storage reuse-safe via clear()+reserve()+push_back so the vector holds exactly the current call's points -- no stale points leak when one ResampleBoundingBoxComputer instance is reused across differing boundary counts (shrinking then growing). - Add a diagnostic (unserialized) numberOfBoundaryPoints so tests can confirm full-boundary (not corners-only) sampling. paddedSize stays clamped to >= 0. resample-bounding-box-generate-inputs.cxx: - Add a --case selector (2d-translation default, 3d-translation, 2d-rotation) emitting each self-contained fixed/moving/transform set; the rotation uses an itk::AffineTransform (cos .8/sin .6 about center) -> non-axis-aligned corners. resample-bounding-box-test.cxx (new): in-process unit test asserting the exact region for the 2D/3D translation and 2D rotation cases at double precision, plus the hardening (padding symmetry, padding-independent corners, degenerate axis, instance reuse vs fresh). Built/CTest-run only outside Emscripten. CMakeLists.txt: 3D and rotation integration CTests (generate -> run, with DEPENDS) and the unit-test CTest. TypeScript + Python: parametrized case tables (2D/3D translation, 2D affine rotation) with dimension-generic image/transform helpers and an affine helper; assert regions identical to the C++ results, including the padding-0 padded corners (which equal the tight corners only when those fall on grid lines). docs/resample-bounding-box.md (new): structured reference (YAML front matter + [[downsample]]/[[affine-ops]] wiki-links) documenting the inputs, algorithm, exact JSON schema, and intended downstream sub-region fetch. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/downsample/CMakeLists.txt | 59 ++- .../downsample/docs/resample-bounding-box.md | 148 +++++++ .../tests/test_resample_bounding_box.py | 176 +++++--- .../resample-bounding-box-generate-inputs.cxx | 228 ++++++++--- .../downsample/resample-bounding-box-test.cxx | 387 ++++++++++++++++++ packages/downsample/resampleBoundingBox.h | 38 +- .../test/node/resample-bounding-box-test.js | 155 ++++--- 7 files changed, 1012 insertions(+), 179 deletions(-) create mode 100644 packages/downsample/docs/resample-bounding-box.md create mode 100644 packages/downsample/resample-bounding-box-test.cxx diff --git a/packages/downsample/CMakeLists.txt b/packages/downsample/CMakeLists.txt index 76461d8d3..19bce042c 100644 --- a/packages/downsample/CMakeLists.txt +++ b/packages/downsample/CMakeLists.txt @@ -37,13 +37,14 @@ set(pipelines resample-bounding-box ) -# resample-bounding-box-generate-inputs only fabricates the self-contained inputs (fixed image, moving -# image, transform) for the resample-bounding-box C++ CTest, which runs under the WASI/native toolchains. -# It is deliberately NOT built for Emscripten: itk-wasm bindgen scans the Emscripten build for pipeline -# .wasm files, so building it there would expose it as a public browser/Node binding. The real, public -# pipeline is 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: itk-wasm bindgen scans the Emscripten build for pipeline .wasm files, +# so building them there would expose them as public browser/Node bindings. The real, public pipeline is +# resample-bounding-box. if(NOT EMSCRIPTEN) - list(APPEND pipelines resample-bounding-box-generate-inputs) + list(APPEND pipelines resample-bounding-box-generate-inputs resample-bounding-box-test) endif() foreach(pipeline ${pipelines}) @@ -113,4 +114,50 @@ if(NOT EMSCRIPTEN) ) 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..a8beccc3f --- /dev/null +++ b/packages/downsample/docs/resample-bounding-box.md @@ -0,0 +1,148 @@ +--- +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. **Boundary-pixel sampling.** Enumerate every *boundary* pixel of the fixed grid — every pixel with at least one + index component equal to `0` or `size_d - 1`. This is all faces and edges, not merely the `2^N` 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 boundary pixel's physical location 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). + +### Why the full boundary, not just corners + +For a purely **affine** transform (translation, 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 and sampling the full boundary gives +the same answer. Enumerating the entire boundary matters 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 algorithm +therefore always walks the full boundary. (The C++ unit test asserts the boundary-pixel count directly — e.g. 56 +for a 20×10 grid versus 4 if only corners were sampled — to guard against a regression to corners-only sampling.) + +### 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.0, 24.0], "max": [51.0, 56.0] }, + "corners": { "min": [20.0, 25.0], "max": [50.0, 55.0] } +} +``` + +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/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py b/packages/downsample/python/itkwasm-downsample-wasi/tests/test_resample_bounding_box.py index e3dec4025..4a21c9ea9 100644 --- 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 @@ -20,15 +20,18 @@ # 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 +# 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 2D, single-component, uint8 Image with the given geometry and an EMPTY pixel buffer.""" + """A single-component, uint8 Image of arbitrary dimension with the given geometry and an EMPTY pixel buffer.""" + dimension = len(size) image_type = ImageType( - dimension=2, + dimension=dimension, componentType=IntTypes.UInt8, pixelType=PixelTypes.Scalar, components=1, @@ -37,28 +40,29 @@ def metadata_only_image(size, spacing, origin): imageType=image_type, origin=origin, spacing=spacing, - direction=np.eye(2, dtype=np.float64), # identity + 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 2D, float64 TranslationTransform with the given 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=2, - outputDimension=2, + inputDimension=dimension, + outputDimension=dimension, ) transform = Transform( transformType=transform_type, numberOfFixedParameters=0, - numberOfParameters=2, + numberOfParameters=dimension, fixedParameters=np.empty((0,), dtype=np.float64), parameters=np.asarray(offset, dtype=np.float64), name="TranslationTransform", @@ -66,65 +70,107 @@ def translation_transform(offset): return [transform] -# Shared geometry (matches the self-contained C++ CTest inputs, whose output is independently verified, and the -# TypeScript node test): -# fixed : 16x16, spacing (2,2), origin (10,20) -> physical grid [10,40] x [20,50] -# moving: 64x64, spacing (1,1), origin (0, 0) -> continuous index == physical coordinate -# transform: translation (10,5) -> fixed grid maps to [20,50] x [25,55] -# The tight (unpadded) moving-image region is therefore start (20,25), inclusive-end (50,55). -def fixed_image(): - return metadata_only_image([16, 16], [2, 2], [10, 20]) +def affine_transform(matrix_row_major, translation, center): + """A single-entry TransformList holding a float64 AffineTransform. - -def moving_image(): - return metadata_only_image([64, 64], [1, 1], [0, 0]) - - -def transform(): - return translation_transform([10, 5]) - - -def test_resample_bounding_box(): - """With one pixel of padding per side, the reported region bounds the translated fixed grid plus one pixel.""" - result = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=1) - - # Tight corners are padding-independent: the translated fixed grid, [20,50] x [25,55]. - assert result["corners"]["min"] == pytest.approx([20, 25]) - assert result["corners"]["max"] == pytest.approx([50, 55]) - - # With one pixel of padding per side the integer region grows outward by one on every side. - assert result["paddedStartIndex"] == [19, 24] - assert result["paddedSize"] == [33, 33] # (50-20) + 1 tight, +2 for padding => 33 - - # Padded corners are the physical location of the padded start and inclusive-end indices in the moving image. - assert result["paddedCorners"]["min"] == pytest.approx([19, 24]) - assert result["paddedCorners"]["max"] == pytest.approx([51, 56]) - - # Persist the result next to the other Python test outputs for inspection. - with open(test_output_path / "resample-bounding-box.json", "w") as fp: - json.dump(result, fp) - - -def test_resample_bounding_box_padding_zero_shrinks_by_one_per_side(): - """padding=0 shrinks the region by exactly one pixel per side and accepts an empty-data moving image. - - Cross-checks the C++, TypeScript, and Python results against one another: the padding=0 region here is the - same one asserted in the TypeScript test, and the shrink relationship mirrors it exactly. + 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. """ - padded = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=1) - tight = resample_bounding_box(transform(), fixed_image(), moving_image(), padding=0) - - # The empty-data moving image was accepted without error (the metadata-only contract holds), and padding=0 - # was actually forwarded (a falsy 0 must not fall back to the C++ default of 1). - assert tight["paddedStartIndex"] == [20, 25] - assert tight["paddedSize"] == [31, 31] + 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] - # With no padding the integer region is exactly the tight corners. - assert tight["paddedCorners"]["min"] == pytest.approx(tight["corners"]["min"]) - assert tight["paddedCorners"]["max"] == pytest.approx(tight["corners"]["max"]) - # Compared with the default (padding 1), padding 0 shrinks the region by exactly one pixel on every side: - # the start index moves in by one and the size shrinks by two (one per side) on each axis. - for axis in range(2): +# 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/resample-bounding-box-generate-inputs.cxx b/packages/downsample/resample-bounding-box-generate-inputs.cxx index 0f31f9a93..3d44287fe 100644 --- a/packages/downsample/resample-bounding-box-generate-inputs.cxx +++ b/packages/downsample/resample-bounding-box-generate-inputs.cxx @@ -16,17 +16,29 @@ * *=========================================================================*/ -// Self-contained generator of the inputs for the resample-bounding-box test. It writes a fixed -// metadata image, a moving metadata image, and a translation transform entirely through the -// WebAssembly interface (.iwi / .iwt), so no image-format IO is required. +// 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. // -// With these inputs and --padding 1, resample-bounding-box should report, for the moving image: -// fixed grid: 16 x 16, spacing (2, 2), origin (10, 20) -> physical span [10,40] x [20,50] -// translation (10, 5): transformed span [20,50] x [25,55] -// moving grid: 64 x 64, spacing (1, 1), origin (0, 0) -> continuous index == physical -// => corners: min (20, 25), max (50, 55) -// => paddedStartIndex: (19, 24), paddedSize: (33, 33) -// => paddedCorners: min (19, 24), max (51, 56) +// --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" @@ -34,68 +46,182 @@ #include "itkImage.h" #include "itkTranslationTransform.h" +#include "itkAffineTransform.h" -int -main(int argc, char * argv[]) +#include +#include + +namespace { - itk::wasm::Pipeline pipeline( - "resample-bounding-box-generate-inputs", "Generate the inputs for the resample-bounding-box test.", argc, argv); +// 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 +typename itk::Image::Pointer +makeMetadataImage(const std::array & size, + const std::array & spacing, + const std::array & origin) +{ + using ImageType = itk::Image; + 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; using TransformType = itk::TranslationTransform; itk::wasm::OutputImage fixedImage; pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE"); - itk::wasm::OutputImage movingImage; pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE"); + itk::wasm::OutputTransform 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; + using TransformType = itk::TranslationTransform; + + itk::wasm::OutputImage fixedImage; + pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE"); + itk::wasm::OutputImage movingImage; + pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE"); itk::wasm::OutputTransform transform; - pipeline.add_option("transform", transform, "Output translation transform") - ->required() - ->type_name("OUTPUT_TRANSFORM"); + pipeline.add_option("transform", transform, "Output translation transform")->required()->type_name("OUTPUT_TRANSFORM"); ITK_WASM_PARSE(pipeline); - // Fixed image: 16 x 16, spacing (2, 2), non-zero origin (10, 20), identity direction. - auto fixed = ImageType::New(); - ImageType::SizeType fixedSize = { { 16, 16 } }; - ImageType::RegionType fixedRegion(fixedSize); - fixed->SetRegions(fixedRegion); - ImageType::SpacingType fixedSpacing; - fixedSpacing[0] = 2.0; - fixedSpacing[1] = 2.0; - fixed->SetSpacing(fixedSpacing); - ImageType::PointType fixedOrigin; - fixedOrigin[0] = 10.0; - fixedOrigin[1] = 20.0; - fixed->SetOrigin(fixedOrigin); - fixed->Allocate(); - fixed->FillBuffer(0); - fixedImage.Set(fixed); - - // Moving image: 64 x 64, spacing (1, 1), origin (0, 0); large enough to contain the transformed grid. - auto moving = ImageType::New(); - ImageType::SizeType movingSize = { { 64, 64 } }; - ImageType::RegionType movingRegion(movingSize); - moving->SetRegions(movingRegion); - ImageType::SpacingType movingSpacing; - movingSpacing.Fill(1.0); - moving->SetSpacing(movingSpacing); - ImageType::PointType movingOrigin; - movingOrigin.Fill(0.0); - moving->SetOrigin(movingOrigin); - moving->Allocate(); - moving->FillBuffer(0); - movingImage.Set(moving); - - // Translation transform: (10, 5). + 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; + using TransformType = itk::AffineTransform; + + itk::wasm::OutputImage fixedImage; + pipeline.add_option("fixed", fixedImage, "Output fixed metadata image")->required()->type_name("OUTPUT_IMAGE"); + itk::wasm::OutputImage movingImage; + pipeline.add_option("moving", movingImage, "Output moving metadata image")->required()->type_name("OUTPUT_IMAGE"); + itk::wasm::OutputTransform 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..2bf335850 --- /dev/null +++ b/packages/downsample/resample-bounding-box-test.cxx @@ -0,0 +1,387 @@ +/*========================================================================= + * + * 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 Phase-04 hardening: full-boundary (not corners-only) sampling, symmetric padding, +// padding-independent tight corners, a degenerate zero-size axis, and reuse of one instance across differing +// boundary counts. It never touches a pixel buffer, matching the pipeline's metadata-only contract. + +#include +#include +#include +#include +#include +#include +#include + +#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 +void +printVec(const std::string & prefix, const std::vector & 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 +void +checkIntVec(const std::vector & actual, const std::vector & 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(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 & actual, + const std::vector & 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 +typename itk::Image::Pointer +makeImage(const std::array & size, + const std::array & spacing, + const std::array & origin) +{ + using ImageType = itk::Image; + 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::Pointer +rotationAffine() +{ + using AffineType = itk::AffineTransform; + 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; +} + +// ---- 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; + 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::New(); + itk::TranslationTransform::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + translation->SetOffset(offset); + const TransformType * transform = translation.GetPointer(); + + ResampleBoundingBoxComputer 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"); + // 16*16 total - 14*14 interior = 60 boundary pixels (all four edges), not just the 4 corners. + checkTrue(result.numberOfBoundaryPoints == 60, "2D translation samples the full boundary (60 pixels)"); +} + +// ---- 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; + 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::New(); + itk::TranslationTransform::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + offset[2] = 3.0; + translation->SetOffset(offset); + const TransformType * transform = translation.GetPointer(); + + ResampleBoundingBoxComputer 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"); + // 8^3 total - 6^3 interior = 296 boundary voxels (all six faces), not just the 8 corners. + checkTrue(result.numberOfBoundaryPoints == 296, "3D translation samples the full boundary (296 voxels)"); + + // 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, the tight bound is achieved at the four rotated CORNERS +// -- so asserting the reported corners equal the analytic transformed-corner extremes confirms the region tightly +// bounds the rotated grid. The exhaustive boundary enumeration (verified via numberOfBoundaryPoints below) is what +// additionally keeps NONLINEAR transforms bounded, where interior edge pixels can exceed the transformed corners. +void +test2DRotation() +{ + using TransformType = itk::Transform; + 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 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"); + // 20*10 total - 18*8 interior = 56 boundary pixels. A corners-only implementation would sample only 4; asserting + // 56 proves the full boundary (every edge pixel) is transformed. + checkTrue(result.numberOfBoundaryPoints == 56, "2D rotation samples the full boundary, not just corners (56 vs 4)"); +} + +// ---- Padding is symmetric per side, and the unpadded (tight) corners are padding-independent. ---- +void +testPaddingSymmetry() +{ + using TransformType = itk::Transform; + 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::New(); + itk::TranslationTransform::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + translation->SetOffset(offset); + const TransformType * transform = translation.GetPointer(); + + ResampleBoundingBoxComputer 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(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; + 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::New(); + itk::TranslationTransform::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + translation->SetOffset(offset); + const TransformType * transform = translation.GetPointer(); + + ResampleBoundingBoxComputer 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; +} + +// ---- 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. +void +testInstanceReuse() +{ + using TransformType = itk::Transform; + auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 }); + auto translation = itk::TranslationTransform::New(); + itk::TranslationTransform::OutputVectorType offset; + offset[0] = 10.0; + offset[1] = 5.0; + translation->SetOffset(offset); + const TransformType * transform = translation.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 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 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(); + 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/resampleBoundingBox.h b/packages/downsample/resampleBoundingBox.h index be820b77f..301f505d4 100644 --- a/packages/downsample/resampleBoundingBox.h +++ b/packages/downsample/resampleBoundingBox.h @@ -39,6 +39,11 @@ struct ResampleBoundingBoxResult std::vector paddedCornersMax; std::vector cornersMin; std::vector cornersMax; + + // Diagnostic only (NOT part of the serialized JSON contract): the number of fixed-image boundary pixels that + // were sampled and transformed. Exposed so tests can confirm the algorithm walks the full boundary -- every + // face and edge -- rather than only the 2^Dimension corners, which is what keeps nonlinear transforms bounded. + std::size_t numberOfBoundaryPoints = 0; }; /** \class ResampleBoundingBoxComputer @@ -89,16 +94,35 @@ class ResampleBoundingBoxComputer } const itk::SizeValueType boundaryCount = totalCount - interiorCount; - // Reuse the member vector's storage across calls. - m_BoundaryPoints.resize(boundaryCount); + // 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 boundary count changes between + // calls (e.g. shrinking then growing the fixed image): the size always matches the current call, so no stale + // point from an earlier, larger call can leak into the bounding box. + m_BoundaryPoints.clear(); + m_BoundaryPoints.reserve(boundaryCount); // 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. - itk::SizeValueType count = 0; - IndexType index = startIndex; + IndexType index = startIndex; while (true) { bool onBoundary = false; @@ -118,8 +142,9 @@ class ResampleBoundingBoxComputer index[0] = startIndex[0] + static_cast(size[0]) - 1; } - fixedImage->TransformIndexToPhysicalPoint(index, m_BoundaryPoints[count]); - ++count; + PointType physicalPoint; + fixedImage->TransformIndexToPhysicalPoint(index, physicalPoint); + m_BoundaryPoints.push_back(physicalPoint); // Odometer increment, fastest axis first. unsigned int d = 0; @@ -137,6 +162,7 @@ class ResampleBoundingBoxComputer 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. diff --git a/packages/downsample/typescript/test/node/resample-bounding-box-test.js b/packages/downsample/typescript/test/node/resample-bounding-box-test.js index 2a523c46a..9d702a561 100644 --- a/packages/downsample/typescript/test/node/resample-bounding-box-test.js +++ b/packages/downsample/typescript/test/node/resample-bounding-box-test.js @@ -16,80 +16,133 @@ 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. +// 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. -// A 2D, single-component, uint8 image with the given geometry and an EMPTY pixel buffer. +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 imageType = new ImageType(2, IntTypes.UInt8, PixelTypes.Scalar, 1) + 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 = Float64Array.from([1, 0, 0, 1]) // identity + image.direction = identityDirection(dimension) image.data = new Uint8Array(0) // no pixels -- exercise the metadata-only contract return image } -// A single-entry TransformList holding a 2D, float64 TranslationTransform with the given offset. +// A single-entry TransformList holding a float64 TranslationTransform (dimension inferred from the offset). function translationTransform (offset) { - const transformType = new TransformType( - TransformParameterizations.Translation, - FloatTypes.Float64, - 2, - 2 - ) + 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 = 2 + transform.numberOfParameters = dimension transform.fixedParameters = Float64Array.from([]) transform.parameters = Float64Array.from(offset) return [transform] } -// Shared geometry (matches the self-contained C++ CTest inputs, whose output is independently verified): -// fixed : 16x16, spacing (2,2), origin (10,20) -> physical grid [10,40] x [20,50] -// moving: 64x64, spacing (1,1), origin (0, 0) -> continuous index == physical coordinate -// transform: translation (10,5) -> fixed grid maps to [20,50] x [25,55] -// The tight (unpadded) moving-image region is therefore start (20,25), inclusive-end (50,55). -const fixedImage = () => metadataOnlyImage([16, 16], [2, 2], [10, 20]) -const movingImage = () => metadataOnlyImage([64, 64], [1, 1], [0, 0]) -const transform = () => translationTransform([10, 5]) - -test('resampleBoundingBoxNode returns the padded region for a translation (padding 1)', async t => { - const { boundingBox } = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { - padding: 1 - }) +// 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] +} - // Tight corners are padding-independent: the translated fixed grid, [20,50] x [25,55]. - t.deepEqual(boundingBox.corners.min, [20, 25]) - t.deepEqual(boundingBox.corners.max, [50, 55]) +// 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]}`) + } +} - // With one pixel of padding per side the integer region grows outward by one on every side. - t.deepEqual(boundingBox.paddedStartIndex, [19, 24]) - t.deepEqual(boundingBox.paddedSize, [33, 33]) // (50-20) + 1 tight, +2 for padding => 33 +// 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] } + } +] - // Padded corners are the physical location of the padded start and inclusive-end indices in the moving image. - t.deepEqual(boundingBox.paddedCorners.min, [19, 24]) - t.deepEqual(boundingBox.paddedCorners.max, [51, 56]) -}) +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 }) -test('resampleBoundingBoxNode with padding 0 shrinks by exactly one pixel per side and accepts empty pixel data', async t => { - const padded = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { padding: 1 }) - const tight = await resampleBoundingBoxNode(transform(), fixedImage(), movingImage(), { padding: 0 }) + // 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) - // The empty-data moving image was accepted without error (metadata-only contract holds). - t.deepEqual(tight.boundingBox.paddedStartIndex, [20, 25]) - t.deepEqual(tight.boundingBox.paddedSize, [31, 31]) + 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) - // With no padding the region is exactly the tight corners. - t.deepEqual(tight.boundingBox.paddedCorners.min, tight.boundingBox.corners.min) - t.deepEqual(tight.boundingBox.paddedCorners.max, tight.boundingBox.corners.max) + // 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) - // Compared with the default (padding 1), padding 0 shrinks the region by exactly one pixel on every side: - // the start index moves in by one and the size shrinks by two (one per side) on each axis. - for (let axis = 0; axis < 2; axis++) { - t.is(tight.boundingBox.paddedStartIndex[axis], padded.boundingBox.paddedStartIndex[axis] + 1) - t.is(tight.boundingBox.paddedSize[axis], padded.boundingBox.paddedSize[axis] - 2) - } -}) + 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) + } + }) +} From 9849165fde89814c6166af3b8467b500d1463898 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 3 Jul 2026 12:54:32 -0400 Subject: [PATCH 5/9] fix(downsample): declare @itk-wasm/transform-io devDependency for demo build The resample-bounding-box browser demo controller imports readTransform from @itk-wasm/transform-io, but the package was never declared as a dependency of @itk-wasm/downsample. The production `vite build` (build:demo) therefore failed in CI with "Rollup failed to resolve import @itk-wasm/transform-io", breaking the downsample Node.js Tests job at the build:gen:typescript step. Add @itk-wasm/transform-io (workspace:^) to the TypeScript package's devDependencies alongside the other sibling io packages, and record the corresponding entry in pnpm-lock.yaml. The demo build now resolves the import (vite build: 716 modules transformed, previously failed at 13). Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/downsample/typescript/package.json | 1 + pnpm-lock.yaml | 3 +++ 2 files changed, 4 insertions(+) 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/pnpm-lock.yaml b/pnpm-lock.yaml index bf3081571..82e06ee00 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -631,6 +631,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 From c135ee108120b82ac28c77d8e1982873da087229 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 3 Jul 2026 14:05:44 -0400 Subject: [PATCH 6/9] fix(downsample): exclude resample-bounding-box-test from Python bindgen The Python bindings are generated by scanning the WASI build, which -- unlike the Emscripten build that TypeScript bindgen scans -- contains the CTest-only executables built under `if(NOT EMSCRIPTEN)`: both resample-bounding-box- generate-inputs AND resample-bounding-box-test. Only the former was listed in `itk-wasm.bindgen-exclude`, so bindgen tried to extract an interface JSON from the resample-bounding-box-test unit-test binary, which is not an itk-wasm pipeline. That yields an empty interface object, and package-dunder-init.js then calls snakeCase(interfaceJson.name) on undefined, crashing the `bindgen:python` step of the downsample Python CI job: TypeError: Cannot read properties of undefined (reading 'replaceAll') at snakeCase (.../bindgen/snake-case.js:2:20) Add resample-bounding-box-test to bindgen-exclude, and expand the CMakeLists comment to note that the WASI build (scanned by Python bindgen) contains these binaries, so any CTest-only executable must be excluded there too. Verified by running `itk-wasm -b wasi-build bindgen --interface python` against the local WASI build: it now exits 0 and the generated itkwasm_downsample __init__.py imports only the six real pipelines (no *_test / *_generate_inputs modules); the committed Python snapshot is unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/downsample/CMakeLists.txt | 6 ++++-- packages/downsample/package.json | 3 ++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/packages/downsample/CMakeLists.txt b/packages/downsample/CMakeLists.txt index 19bce042c..69ca2f36d 100644 --- a/packages/downsample/CMakeLists.txt +++ b/packages/downsample/CMakeLists.txt @@ -40,8 +40,10 @@ set(pipelines # 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: itk-wasm bindgen scans the Emscripten build for pipeline .wasm files, -# so building them there would expose them as public browser/Node bindings. The real, public pipeline is +# 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) diff --git a/packages/downsample/package.json b/packages/downsample/package.json index 97a581eab..8ea39bf1d 100644 --- a/packages/downsample/package.json +++ b/packages/downsample/package.json @@ -16,7 +16,8 @@ "package-description": "Pipelines for downsampling images.", "repository": "https://github.com/InsightSoftwareConsortium/ITK-Wasm", "bindgen-exclude": [ - "resample-bounding-box-generate-inputs" + "resample-bounding-box-generate-inputs", + "resample-bounding-box-test" ] }, "scripts": { From cc06dcda30037829c72c5ae56e53b7f80b312d8d Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Fri, 3 Jul 2026 16:24:10 -0400 Subject: [PATCH 7/9] fix(downsample): build @itk-wasm/transform-io in CI so the demo bundles The resample-bounding-box browser demo controller imports readTransform from @itk-wasm/transform-io, so the production `vite build` (build:demo) must be able to resolve that package's built entry. A prior commit declared @itk-wasm/transform-io as a devDependency of the @itk-wasm/downsample TypeScript package, which fixed the "Rollup failed to resolve import" error -- but exposed the next one: vite then failed with [commonjs--resolver] Failed to resolve entry for package "@itk-wasm/transform-io". The package may have incorrect main/module/exports specified in its package.json. i.e. the package resolves, but its dist/ was never built in CI. The downsample Node.js job builds `pnpm --filter "@itk-wasm/downsample-build..." build:gen: typescript`; the sibling io packages get built only because their *-build packages are devDependencies of @itk-wasm/downsample-build (image-io-build, compare-images-build). transform-io-build was missing from that list, so transform-io never entered the build closure and its dist was absent when the demo bundled. Add @itk-wasm/transform-io-build (workspace:^) to @itk-wasm/downsample-build's devDependencies (and the matching pnpm-lock.yaml importer entry) so transform- io's build:gen:typescript runs -- topologically before the downsample demo build -- and its dist is present. Verified: `pnpm install` reports the lockfile is up to date, and @itk-wasm/transform-io-build now appears in the `@itk-wasm/downsample-build...` filter closure with a build:gen:typescript script. transform-io is imported only by the browser demo (not the node tests, which build the transform inline), so this fully covers the failing step. Co-Authored-By: Claude Opus 4.8 (1M context) --- packages/downsample/package.json | 3 ++- pnpm-lock.yaml | 3 +++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/downsample/package.json b/packages/downsample/package.json index 8ea39bf1d..3732998a2 100644 --- a/packages/downsample/package.json +++ b/packages/downsample/package.json @@ -45,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/pnpm-lock.yaml b/pnpm-lock.yaml index 82e06ee00..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 From b05421bba5120cc66e5f0e3303462ec25e189137 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Mon, 6 Jul 2026 11:29:48 -0400 Subject: [PATCH 8/9] perf(downsample): corners-only fast path for linear transforms in resample-bounding-box ResampleBoundingBoxComputer sampled every fixed-grid boundary pixel (all faces and edges) for every transform. That is only necessary for NONLINEAR transforms, where an interior edge pixel can map outside the hull of the transformed corners. For a LINEAR transform (translation, rigid, similarity, affine) the image of the fixed rectangle is convex, so its axis-aligned bound is already attained at the 2^Dimension transformed corners -- 4 in 2D, 8 in 3D, 16 in 4D -- independent of image size. Detect linearity with itk::Transform::IsLinear() (i.e. GetTransformCategory() == Linear), which dispatches polymorphically through the abstract base the pipeline already holds, and take a corners-only fast path in that case; keep the full boundary walk for nonlinear transforms. Both paths feed the identical min/max accumulation, so the computed region is unchanged for linear transforms -- the existing 2D/3D translation and 2D affine-rotation assertions (and the TypeScript and Python suites, which use only linear transforms) pass byte-for-byte, now via the corners. The corner enumeration is a bitmask over Dimension bits (bit d selects the low or high index on axis d); a size-1 axis harmlessly duplicates corners. The degenerate zero-size-axis early return is unchanged and still precedes path selection. Tests and docs: - Add a `usedLinearCornerPath` diagnostic to ResampleBoundingBoxResult; repurpose the existing numberOfBoundaryPoints assertions to confirm the linear cases now sample exactly 2^Dimension corners while producing the same region. - Add test2DNonlinearBoundary with a custom nonlinear "bulge" transform whose right-edge midpoint maps beyond the transformed corners, asserting the full-boundary path is taken (56 samples) and that its +x extent exceeds the corners-only bound -- locking in that the boundary walk still triggers, and matters, exactly when the transform is nonlinear. - Switch testInstanceReuse to the nonlinear transform so the reused, variable-size boundary storage is actually exercised (the linear path is a fixed 2^Dimension). - Update docs/resample-bounding-box.md to describe both paths. Verified natively against ITK 5.4 (-Wall -Wextra -Werror, clean): all unit checks pass. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../downsample/docs/resample-bounding-box.md | 40 +++-- .../downsample/resample-bounding-box-test.cxx | 164 +++++++++++++++--- packages/downsample/resampleBoundingBox.h | 128 +++++++++----- 3 files changed, 253 insertions(+), 79 deletions(-) diff --git a/packages/downsample/docs/resample-bounding-box.md b/packages/downsample/docs/resample-bounding-box.md index a8beccc3f..81c00145f 100644 --- a/packages/downsample/docs/resample-bounding-box.md +++ b/packages/downsample/docs/resample-bounding-box.md @@ -56,13 +56,18 @@ and only then move real pixels. For a fixed image of dimension *N*: -1. **Boundary-pixel sampling.** Enumerate every *boundary* pixel of the fixed grid — every pixel with at least one - index component equal to `0` or `size_d - 1`. This is all faces and edges, not merely the `2^N` 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 boundary pixel's physical location 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. +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` @@ -70,15 +75,20 @@ For a fixed image of dimension *N*: 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). -### Why the full boundary, not just corners +### Corner fast path vs. full-boundary sampling -For a purely **affine** transform (translation, 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 and sampling the full boundary gives -the same answer. Enumerating the entire boundary matters 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 algorithm -therefore always walks the full boundary. (The C++ unit test asserts the boundary-pixel count directly — e.g. 56 -for a 20×10 grid versus 4 if only corners were sampled — to guard against a regression to corners-only 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 diff --git a/packages/downsample/resample-bounding-box-test.cxx b/packages/downsample/resample-bounding-box-test.cxx index 2bf335850..390e36195 100644 --- a/packages/downsample/resample-bounding-box-test.cxx +++ b/packages/downsample/resample-bounding-box-test.cxx @@ -21,9 +21,12 @@ // 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 Phase-04 hardening: full-boundary (not corners-only) sampling, symmetric padding, -// padding-independent tight corners, a degenerate zero-size axis, and reuse of one instance across differing -// boundary counts. It never touches a pixel buffer, matching the pipeline's metadata-only contract. +// 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 #include @@ -155,6 +158,78 @@ rotationAffine() 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 +{ +public: + ITK_DISALLOW_COPY_AND_MOVE(EdgeBulgeTransform2D); + + using Self = EdgeBulgeTransform2D; + using Superclass = itk::Transform; + using Pointer = itk::SmartPointer; + using ConstPointer = itk::SmartPointer; + 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() @@ -180,8 +255,10 @@ test2DTranslation() 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"); - // 16*16 total - 14*14 interior = 60 boundary pixels (all four edges), not just the 4 corners. - checkTrue(result.numberOfBoundaryPoints == 60, "2D translation samples the full boundary (60 pixels)"); + // 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). ---- @@ -210,8 +287,10 @@ test3DTranslation() 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"); - // 8^3 total - 6^3 interior = 296 boundary voxels (all six faces), not just the 8 corners. - checkTrue(result.numberOfBoundaryPoints == 296, "3D translation samples the full boundary (296 voxels)"); + // 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; @@ -222,10 +301,11 @@ test3DTranslation() // ---- 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, the tight bound is achieved at the four rotated CORNERS -// -- so asserting the reported corners equal the analytic transformed-corner extremes confirms the region tightly -// bounds the rotated grid. The exhaustive boundary enumeration (verified via numberOfBoundaryPoints below) is what -// additionally keeps NONLINEAR transforms bounded, where interior edge pixels can exceed the transformed corners. +// 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() { @@ -246,9 +326,49 @@ test2DRotation() 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"); - // 20*10 total - 18*8 interior = 56 boundary pixels. A corners-only implementation would sample only 4; asserting - // 56 proves the full boundary (every edge pixel) is transformed. - checkTrue(result.numberOfBoundaryPoints == 56, "2D rotation samples the full boundary, not just corners (56 vs 4)"); + // 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; + 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 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. ---- @@ -318,24 +438,23 @@ resultsEqual(const ResampleBoundingBoxResult & a, const ResampleBoundingBoxResul 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.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. +// 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; auto moving = makeImage<2>({ 64, 64 }, { 1.0, 1.0 }, { 0.0, 0.0 }); - auto translation = itk::TranslationTransform::New(); - itk::TranslationTransform::OutputVectorType offset; - offset[0] = 10.0; - offset[1] = 5.0; - translation->SetOffset(offset); - const TransformType * transform = translation.GetPointer(); + 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 @@ -373,6 +492,7 @@ main() test2DTranslation(); test3DTranslation(); test2DRotation(); + test2DNonlinearBoundary(); testPaddingSymmetry(); testDegenerateAxis(); testInstanceReuse(); diff --git a/packages/downsample/resampleBoundingBox.h b/packages/downsample/resampleBoundingBox.h index 301f505d4..fd2c2c37a 100644 --- a/packages/downsample/resampleBoundingBox.h +++ b/packages/downsample/resampleBoundingBox.h @@ -40,10 +40,15 @@ struct ResampleBoundingBoxResult std::vector cornersMin; std::vector cornersMax; - // Diagnostic only (NOT part of the serialized JSON contract): the number of fixed-image boundary pixels that - // were sampled and transformed. Exposed so tests can confirm the algorithm walks the full boundary -- every - // face and edge -- rather than only the 2^Dimension corners, which is what keeps nonlinear transforms bounded. + // 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 @@ -56,8 +61,16 @@ struct ResampleBoundingBoxResult * data buffers. * * TTransform is expected to be the abstract itk::Transform - * base instantiated by itk::wasm::SupportInputTransformTypes, so TransformPoint() is - * dispatched polymorphically to the concrete transform. + * 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 class ResampleBoundingBoxComputer @@ -111,55 +124,86 @@ class ResampleBoundingBoxComputer // 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 boundary count changes between - // calls (e.g. shrinking then growing the fixed image): the size always matches the current call, so no stale - // point from an earlier, larger call can leak into the bounding box. + // 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(); - m_BoundaryPoints.reserve(boundaryCount); - - // 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. - IndexType index = startIndex; - while (true) + + // 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) { - bool onBoundary = false; - for (unsigned int d = 0; d < Dimension; ++d) + // 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) { - const itk::IndexValueType rel = index[d] - startIndex[d]; - if (rel == 0 || rel == static_cast(size[d]) - 1) + IndexType index; + for (unsigned int d = 0; d < Dimension; ++d) { - onBoundary = true; - break; + const itk::IndexValueType last = startIndex[d] + static_cast(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); } - if (!onBoundary) + } + 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) { - // 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(size[0]) - 1; - } + 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(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(size[0]) - 1; + } - PointType physicalPoint; - fixedImage->TransformIndexToPhysicalPoint(index, physicalPoint); - m_BoundaryPoints.push_back(physicalPoint); + 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(size[d])) + // Odometer increment, fastest axis first. + unsigned int d = 0; + for (; d < Dimension; ++d) + { + ++index[d]; + if (index[d] < startIndex[d] + static_cast(size[d])) + { + break; + } + index[d] = startIndex[d]; + } + if (d == Dimension) { break; } - index[d] = startIndex[d]; - } - if (d == Dimension) - { - break; } } result.numberOfBoundaryPoints = m_BoundaryPoints.size(); From 2e09c683cfdb32a32632e68ade1648c63355e4f7 Mon Sep 17 00:00:00 2001 From: Matt McCormick Date: Tue, 7 Jul 2026 09:53:38 -0400 Subject: [PATCH 9/9] refactor(downsample): serialize resample-bounding-box output with glaze instead of rapidjson Replace the hand-built rapidjson DOM in resample-bounding-box.cxx with glaze (glz::write_json). Two small structs -- CornersJSON and BoundingBox -- mirror the output schema, and glaze serializes their public members by name in declaration order via compile-time reflection, so the ~55 lines of Value/AddMember/PushBack boilerplate (and three lambdas) collapse to a struct literal plus one write call. Write errors are reported through the same CLI::Error / pipeline.exit() path the file already uses for the dimension-dispatch error. glaze is already a dependency of this translation unit (resampleReadInputTransform.h uses it) and reaches the include path transitively via the WebAssemblyInterface ITK module, so no CMakeLists change is needed. Two behaviors worth noting: - Linkage: the serialization structs are placed in a NAMED namespace, not an anonymous one. glaze's member-name reflection instantiates a helper over the type, which the (emscripten/clang) toolchain rejects for a type with internal linkage ("its type does not have linkage"). A named namespace gives external linkage while still scoping the generic type names. - Number format: glaze writes the shortest round-trippable form, so an integer-valued double serializes without a trailing ".0" (e.g. 19, not 19.0). The JSON value is identical and every binding parses it as a float. All test suites compare numeric values, not text: the C++ unit test uses the in-memory ResampleBoundingBoxResult (no JSON), and the TypeScript (closeTo / deepEqual) and Python (pytest.approx / ==) suites parse then compare -- and the integer index arrays (paddedStartIndex, paddedSize) serialize identically to before. Non-integer corners keep full double precision. docs/resample-bounding-box.md worked example updated to the actual compact output, with a note. Verified against the real glaze 2.9.5 in the itkwasm images: the pipeline compiles and links under emscripten, and a WASI build passes all 7 resample-bounding-box CTests. The emitted JSON for the 2D-translation, 3D- translation, and 2D-affine-rotation cases matches the expected regions (e.g. 2D translation -> {"paddedStartIndex":[19,24],"paddedSize":[33,33],...}). Co-Authored-By: Claude Opus 4.8 (1M context) --- .../downsample/docs/resample-bounding-box.md | 12 +- packages/downsample/resample-bounding-box.cxx | 105 ++++++++---------- 2 files changed, 52 insertions(+), 65 deletions(-) diff --git a/packages/downsample/docs/resample-bounding-box.md b/packages/downsample/docs/resample-bounding-box.md index 81c00145f..ea1365979 100644 --- a/packages/downsample/docs/resample-bounding-box.md +++ b/packages/downsample/docs/resample-bounding-box.md @@ -125,14 +125,14 @@ Fixed `16×16`, spacing `(2, 2)`, origin `(10, 20)`; moving `64×64`, spacing `( translation `(10, 5)`; `--padding 1`: ```json -{ - "paddedStartIndex": [19, 24], - "paddedSize": [33, 33], - "paddedCorners": { "min": [19.0, 24.0], "max": [51.0, 56.0] }, - "corners": { "min": [20.0, 25.0], "max": [50.0, 55.0] } -} +{"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. diff --git a/packages/downsample/resample-bounding-box.cxx b/packages/downsample/resample-bounding-box.cxx index e3f4b7905..5e318b9da 100644 --- a/packages/downsample/resample-bounding-box.cxx +++ b/packages/downsample/resample-bounding-box.cxx @@ -37,13 +37,36 @@ #include "itkImage.h" #include "itkTransform.h" -#include "rapidjson/document.h" -#include "rapidjson/stringbuffer.h" -#include "rapidjson/writer.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 min; + std::vector max; +}; + +struct BoundingBox +{ + std::vector paddedStartIndex; + std::vector paddedSize; + CornersJSON paddedCorners; + CornersJSON corners; +}; +} // namespace resampleBoundingBoxJSON + template class PipelineFunctor { @@ -93,62 +116,26 @@ class PipelineFunctor ResampleBoundingBoxResult result; ITK_WASM_CATCH_EXCEPTION(pipeline, computer.Compute(fixed.Get(), moving.Get(), transform, padding, result)); - // Serialize the result to JSON: - // { "paddedStartIndex": [...], "paddedSize": [...], - // "paddedCorners": { "min": [...], "max": [...] }, "corners": { "min": [...], "max": [...] } } - rapidjson::Document document; - document.SetObject(); - rapidjson::Document::AllocatorType & allocator = document.GetAllocator(); - - auto intArray = [&allocator](const std::vector & values) { - rapidjson::Value array(rapidjson::kArrayType); - for (const auto value : values) - { - array.PushBack(rapidjson::Value().SetInt(value), allocator); - } - return array; - }; - auto uintArray = [&allocator](const std::vector & values) { - rapidjson::Value array(rapidjson::kArrayType); - for (const auto value : values) - { - array.PushBack(rapidjson::Value().SetUint(value), allocator); - } - return array; - }; - auto doubleArray = [&allocator](const std::vector & values) { - rapidjson::Value array(rapidjson::kArrayType); - for (const auto value : values) - { - array.PushBack(rapidjson::Value().SetDouble(value), allocator); - } - return array; - }; - - rapidjson::Value paddedStartIndex = intArray(result.paddedStartIndex); - document.AddMember("paddedStartIndex", paddedStartIndex, allocator); - rapidjson::Value paddedSize = uintArray(result.paddedSize); - document.AddMember("paddedSize", paddedSize, allocator); - - rapidjson::Value paddedCorners(rapidjson::kObjectType); - rapidjson::Value paddedCornersMin = doubleArray(result.paddedCornersMin); - paddedCorners.AddMember("min", paddedCornersMin, allocator); - rapidjson::Value paddedCornersMax = doubleArray(result.paddedCornersMax); - paddedCorners.AddMember("max", paddedCornersMax, allocator); - document.AddMember("paddedCorners", paddedCorners, allocator); - - rapidjson::Value corners(rapidjson::kObjectType); - rapidjson::Value cornersMin = doubleArray(result.cornersMin); - corners.AddMember("min", cornersMin, allocator); - rapidjson::Value cornersMax = doubleArray(result.cornersMax); - corners.AddMember("max", cornersMax, allocator); - document.AddMember("corners", corners, allocator); - - rapidjson::StringBuffer stringBuffer; - rapidjson::Writer writer(stringBuffer); - document.Accept(writer); - - boundingBox.Get() << stringBuffer.GetString(); + // 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; }