@fideus-labs/ngff-zarr 0.1.0 → 0.2.1

package/script/methods/itkwasm.js

@@ -1,842 +1,21 @@
 "use strict";
 // SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
 // SPDX-License-Identifier: MIT
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downsampleItkWasm = downsampleItkWasm;
-const downsample_1 = require("@itk-wasm/downsample");
-const zarr = __importStar(require("zarrita"));
-const ngff_image_js_1 = require("../types/ngff_image.js");
-const SPATIAL_DIMS = ["x", "y", "z"];
+exports.downsampleItkWasm = void 0;
 /**
- * Convert dimension scale factors to ITK-Wasm format
- */
-function dimScaleFactors(dims, scaleFactor, previousDimFactors) {
-    const dimFactors = {};
-    if (typeof scaleFactor === "number") {
-        for (const dim of dims) {
-            if (SPATIAL_DIMS.includes(dim)) {
-                dimFactors[dim] = scaleFactor;
-            }
-            else {
-                dimFactors[dim] = previousDimFactors[dim] || 1;
-            }
-        }
-    }
-    else {
-        for (const dim of dims) {
-            if (dim in scaleFactor) {
-                dimFactors[dim] = scaleFactor[dim];
-            }
-            else {
-                dimFactors[dim] = previousDimFactors[dim] || 1;
-            }
-        }
-    }
-    return dimFactors;
-}
-/**
- * Update previous dimension factors
- */
-function updatePreviousDimFactors(scaleFactor, spatialDims, previousDimFactors) {
-    const updated = { ...previousDimFactors };
-    if (typeof scaleFactor === "number") {
-        for (const dim of spatialDims) {
-            updated[dim] = scaleFactor;
-        }
-    }
-    else {
-        for (const dim of spatialDims) {
-            if (dim in scaleFactor) {
-                updated[dim] = scaleFactor[dim];
-            }
-        }
-    }
-    return updated;
-}
-/**
- * Compute next scale metadata
- */
-function nextScaleMetadata(image, dimFactors, spatialDims) {
-    const translation = {};
-    const scale = {};
-    for (const dim of image.dims) {
-        if (spatialDims.includes(dim)) {
-            const factor = dimFactors[dim];
-            scale[dim] = image.scale[dim] * factor;
-            translation[dim] = image.translation[dim] +
-                0.5 * (factor - 1) * image.scale[dim];
-        }
-        else {
-            // Only copy non-spatial dimensions if they exist in the source
-            if (dim in image.scale) {
-                scale[dim] = image.scale[dim];
-            }
-            if (dim in image.translation) {
-                translation[dim] = image.translation[dim];
-            }
-        }
-    }
-    return [translation, scale];
-}
-/**
- * Compute Gaussian kernel sigma values in pixel units for downsampling.
- *
- * Formula: sigma = sqrt((k^2 - 1^2)/(2*sqrt(2*ln(2)))^2)
+ * ITK-Wasm downsampling support for multiscale generation
  *
- * Reference:
- * - https://discourse.itk.org/t/resampling-to-isotropic-signal-processing-theory/1403/16
- * - https://doi.org/10.1007/978-3-319-24571-3_81
- * - http://discovery.ucl.ac.uk/1469251/1/scale-factor-point-5.pdf
+ * This module provides conditional exports for browser and Node environments.
+ * The actual implementation is delegated to environment-specific modules:
+ * - itkwasm-browser.ts: Uses WebWorker-based functions for browser environments
+ * - itkwasm-node.ts: Uses native WASM functions for Node/Deno environments
  *
- * @param shrinkFactors - Shrink ratio along each axis
- * @returns Standard deviation of Gaussian kernel along each axis
- */
-function computeSigma(shrinkFactors) {
-    const denominator = Math.pow(2 * Math.sqrt(2 * Math.log(2)), 2);
-    return shrinkFactors.map((factor) => Math.sqrt((factor * factor - 1) / denominator));
-}
-/**
- * Convert zarr array to ITK-Wasm Image format
- * If isVector is true, ensures "c" dimension is last by transposing if needed
- */
-async function zarrToItkImage(array, dims, isVector = false) {
-    // Read the full array data
-    const result = await zarr.get(array);
-    // Ensure we have the data
-    if (!result.data || result.data.length === 0) {
-        throw new Error("Zarr array data is empty");
-    }
-    let data;
-    let shape = result.shape;
-    let _finalDims = dims;
-    // If vector image, ensure "c" is last dimension
-    if (isVector) {
-        const cIndex = dims.indexOf("c");
-        if (cIndex !== -1 && cIndex !== dims.length - 1) {
-            // Need to transpose to move "c" to the end
-            const permutation = dims.map((_, i) => i).filter((i) => i !== cIndex);
-            permutation.push(cIndex);
-            // Reorder dims
-            _finalDims = permutation.map((i) => dims[i]);
-            // Reorder shape
-            shape = permutation.map((i) => result.shape[i]);
-            // Transpose the data
-            data = transposeArray(result.data, result.shape, permutation, getItkComponentType(result.data));
-        }
-        else {
-            // "c" already at end or not present, just copy data
-            data = copyTypedArray(result.data);
-        }
-    }
-    else {
-        // Not a vector image, just copy data
-        data = copyTypedArray(result.data);
-    }
-    // For vector images, the last dimension is the component count, not a spatial dimension
-    const spatialShape = isVector ? shape.slice(0, -1) : shape;
-    const components = isVector ? shape[shape.length - 1] : 1;
-    // Create ITK-Wasm image
-    const itkImage = {
-        imageType: {
-            dimension: spatialShape.length,
-            componentType: getItkComponentType(data),
-            pixelType: isVector ? "VariableLengthVector" : "Scalar",
-            components,
-        },
-        name: "image",
-        origin: spatialShape.map(() => 0),
-        spacing: spatialShape.map(() => 1),
-        direction: createIdentityMatrix(spatialShape.length),
-        size: spatialShape,
-        data,
-        metadata: new Map(),
-    };
-    return itkImage;
-}
-/**
- * Copy typed array to appropriate type
- */
-function copyTypedArray(data) {
-    if (data instanceof Float32Array) {
-        return new Float32Array(data);
-    }
-    else if (data instanceof Float64Array) {
-        return new Float64Array(data);
-    }
-    else if (data instanceof Uint8Array) {
-        return new Uint8Array(data);
-    }
-    else if (data instanceof Int8Array) {
-        return new Int8Array(data);
-    }
-    else if (data instanceof Uint16Array) {
-        return new Uint16Array(data);
-    }
-    else if (data instanceof Int16Array) {
-        return new Int16Array(data);
-    }
-    else if (data instanceof Uint32Array) {
-        return new Uint32Array(data);
-    }
-    else if (data instanceof Int32Array) {
-        return new Int32Array(data);
-    }
-    else if (data instanceof BigInt64Array) {
-        return new BigInt64Array(data);
-    }
-    else if (data instanceof BigUint64Array) {
-        return new BigUint64Array(data);
-    }
-    else {
-        // Convert to Float32Array as fallback
-        return new Float32Array(data);
-    }
-}
-/**
- * Transpose array data according to permutation
- */
-function transposeArray(data, shape, permutation, componentType) {
-    const typedData = data;
-    // Create output array of same type
-    let output;
-    const totalSize = typedData.length;
-    switch (componentType) {
-        case "uint8":
-            output = new Uint8Array(totalSize);
-            break;
-        case "int8":
-            output = new Int8Array(totalSize);
-            break;
-        case "int16":
-            output = new Int16Array(totalSize);
-            break;
-        case "uint16":
-            output = new Uint16Array(totalSize);
-            break;
-        case "int32":
-            output = new Int32Array(totalSize);
-            break;
-        case "uint32":
-            output = new Uint32Array(totalSize);
-            break;
-        case "int64":
-            output = new BigInt64Array(totalSize);
-            break;
-        case "uint64":
-            output = new BigUint64Array(totalSize);
-            break;
-        case "float64":
-            output = new Float64Array(totalSize);
-            break;
-        case "float32":
-        default:
-            output = new Float32Array(totalSize);
-            break;
-    }
-    // Calculate strides for source
-    const sourceStride = calculateStride(shape);
-    // Calculate new shape after permutation
-    const newShape = permutation.map((i) => shape[i]);
-    const targetStride = calculateStride(newShape);
-    // Perform transpose
-    const indices = new Array(shape.length).fill(0);
-    for (let i = 0; i < totalSize; i++) {
-        // Calculate source index from multi-dimensional indices
-        let sourceIdx = 0;
-        for (let j = 0; j < shape.length; j++) {
-            sourceIdx += indices[j] * sourceStride[j];
-        }
-        // Calculate target index with permuted dimensions
-        let targetIdx = 0;
-        for (let j = 0; j < permutation.length; j++) {
-            targetIdx += indices[permutation[j]] * targetStride[j];
-        }
-        output[targetIdx] = typedData[sourceIdx];
-        // Increment indices
-        for (let j = shape.length - 1; j >= 0; j--) {
-            indices[j]++;
-            if (indices[j] < shape[j])
-                break;
-            indices[j] = 0;
-        }
-    }
-    return output;
-}
-/**
- * Get ITK component type from typed array
- */
-function getItkComponentType(data) {
-    if (data instanceof Uint8Array)
-        return "uint8";
-    if (data instanceof Int8Array)
-        return "int8";
-    if (data instanceof Uint16Array)
-        return "uint16";
-    if (data instanceof Int16Array)
-        return "int16";
-    if (data instanceof Uint32Array)
-        return "uint32";
-    if (data instanceof Int32Array)
-        return "int32";
-    if (data instanceof BigUint64Array)
-        return "uint64";
-    if (data instanceof BigInt64Array)
-        return "int64";
-    if (data instanceof Float64Array)
-        return "float64";
-    return "float32";
-}
-/**
- * Create identity matrix for ITK direction
- */
-function createIdentityMatrix(dimension) {
-    const matrix = new Float64Array(dimension * dimension);
-    for (let i = 0; i < dimension * dimension; i++) {
-        matrix[i] = i % (dimension + 1) === 0 ? 1 : 0;
-    }
-    return matrix;
-}
-/**
- * Convert ITK-Wasm Image back to zarr array
- */
-async function itkImageToZarr(itkImage, path, chunkShape) {
-    // Use in-memory store
-    const store = new Map();
-    const root = zarr.root(store);
-    // Determine data type
-    let dataType;
-    if (itkImage.data instanceof Uint8Array) {
-        dataType = "uint8";
-    }
-    else if (itkImage.data instanceof Int8Array) {
-        dataType = "int8";
-    }
-    else if (itkImage.data instanceof Int16Array) {
-        dataType = "int16";
-    }
-    else if (itkImage.data instanceof Uint16Array) {
-        dataType = "uint16";
-    }
-    else if (itkImage.data instanceof Int32Array) {
-        dataType = "int32";
-    }
-    else if (itkImage.data instanceof Uint32Array) {
-        dataType = "uint32";
-    }
-    else if (itkImage.data instanceof BigInt64Array) {
-        dataType = "int64";
-    }
-    else if (itkImage.data instanceof BigUint64Array) {
-        dataType = "uint64";
-    }
-    else if (itkImage.data instanceof Float64Array) {
-        dataType = "float64";
-    }
-    else if (itkImage.data instanceof Float32Array) {
-        dataType = "float32";
-    }
-    else {
-        dataType = "float32";
-    }
-    const array = await zarr.create(root.resolve(path), {
-        shape: itkImage.size,
-        chunk_shape: chunkShape,
-        data_type: dataType,
-        fill_value: 0,
-    });
-    // Write data
-    await zarr.set(array, [], {
-        data: itkImage.data,
-        shape: itkImage.size,
-        stride: calculateStride(itkImage.size),
-    });
-    return array;
-}
-/**
- * Calculate stride for array
- */
-function calculateStride(shape) {
-    const stride = new Array(shape.length);
-    stride[shape.length - 1] = 1;
-    for (let i = shape.length - 2; i >= 0; i--) {
-        stride[i] = stride[i + 1] * shape[i + 1];
-    }
-    return stride;
-}
-/**
- * Process channel-first data by downsampling each channel separately
- */
-async function downsampleChannelFirst(image, dimFactors, spatialDims, smoothing) {
-    // Get the channel index and count
-    const cIndex = image.dims.indexOf("c");
-    const result = await zarr.get(image.data);
-    const channelCount = result.shape[cIndex];
-    // Process each channel separately
-    const downsampledChannels = [];
-    for (let channelIdx = 0; channelIdx < channelCount; channelIdx++) {
-        // Extract single channel data
-        const channelSlice = extractChannel(result, cIndex, channelIdx);
-        // Create temporary zarr array for this channel
-        const store = new Map();
-        const root = zarr.root(store);
-        const channelDims = image.dims.filter((d) => d !== "c");
-        const channelShape = result.shape.filter((_, i) => i !== cIndex);
-        const chunkShape = channelShape.map((s) => Math.min(s, 256));
-        const channelArray = await zarr.create(root.resolve("channel"), {
-            shape: channelShape,
-            chunk_shape: chunkShape,
-            data_type: getItkComponentType(result.data),
-            fill_value: 0,
-        });
-        await zarr.set(channelArray, [], {
-            data: channelSlice,
-            shape: channelShape,
-            stride: calculateStride(channelShape),
-        });
-        // Create NgffImage for this channel (unused but kept for potential future use)
-        // const _channelImage = new NgffImage({
-        //   data: channelArray,
-        //   dims: channelDims,
-        //   scale: Object.fromEntries(
-        //     Object.entries(image.scale).filter(([k]) => k !== "c")
-        //   ),
-        //   translation: Object.fromEntries(
-        //     Object.entries(image.translation).filter(([k]) => k !== "c")
-        //   ),
-        //   name: image.name,
-        //   axesUnits: image.axesUnits,
-        //   computedCallbacks: image.computedCallbacks,
-        // });
-        // Downsample this channel
-        const itkImage = await zarrToItkImage(channelArray, channelDims, false);
-        const shrinkFactors = [];
-        for (let i = 0; i < channelDims.length; i++) {
-            const dim = channelDims[i];
-            if (SPATIAL_DIMS.includes(dim)) {
-                shrinkFactors.push(dimFactors[dim] || 1);
-            }
-            else {
-                shrinkFactors.push(1); // Non-spatial dimensions don't shrink
-            }
-        }
-        let downsampled;
-        if (smoothing === "gaussian") {
-            const blockSize = itkImage.size.slice().reverse();
-            const sigma = computeSigma(shrinkFactors);
-            const { radius: _radius } = await (0, downsample_1.gaussianKernelRadiusNode)({
-                size: blockSize,
-                sigma,
-            });
-            const result = await (0, downsample_1.downsampleNode)(itkImage, {
-                shrinkFactors,
-                cropRadius: shrinkFactors.map(() => 0),
-            });
-            downsampled = result.downsampled;
-        }
-        else if (smoothing === "bin_shrink") {
-            const result = await (0, downsample_1.downsampleBinShrinkNode)(itkImage, {
-                shrinkFactors,
-            });
-            downsampled = result.downsampled;
-        }
-        else if (smoothing === "label_image") {
-            const blockSize = itkImage.size.slice().reverse();
-            const sigma = computeSigma(shrinkFactors);
-            const { radius: _radius } = await (0, downsample_1.gaussianKernelRadiusNode)({
-                size: blockSize,
-                sigma,
-            });
-            const result = await (0, downsample_1.downsampleLabelImageNode)(itkImage, {
-                shrinkFactors,
-                cropRadius: shrinkFactors.map(() => 0),
-            });
-            downsampled = result.downsampled;
-        }
-        else {
-            throw new Error(`Unknown smoothing method: ${smoothing}`);
-        }
-        // Convert back to zarr array
-        const downsampledChunkShape = downsampled.size.map((s) => Math.min(s, 256));
-        const downsampledArray = await itkImageToZarr(downsampled, "downsampled_channel", downsampledChunkShape);
-        downsampledChannels.push(downsampledArray);
-    }
-    // Combine all channels back together
-    const combinedArray = await combineChannels(downsampledChannels, cIndex, image.dims);
-    // Compute new metadata
-    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
-    return new ngff_image_js_1.NgffImage({
-        data: combinedArray,
-        dims: image.dims,
-        scale,
-        translation,
-        name: image.name,
-        axesUnits: image.axesUnits,
-        computedCallbacks: image.computedCallbacks,
-    });
-}
-/**
- * Extract a single channel from the data
- */
-function extractChannel(result, cIndex, channelIdx) {
-    const typedData = result.data;
-    const shape = result.shape;
-    // Calculate output size (all dims except channel)
-    const outputSize = shape.reduce((acc, s, i) => (i === cIndex ? acc : acc * s), 1);
-    let output;
-    if (typedData instanceof Uint8Array) {
-        output = new Uint8Array(outputSize);
-    }
-    else if (typedData instanceof Int8Array) {
-        output = new Int8Array(outputSize);
-    }
-    else if (typedData instanceof Int16Array) {
-        output = new Int16Array(outputSize);
-    }
-    else if (typedData instanceof Uint16Array) {
-        output = new Uint16Array(outputSize);
-    }
-    else if (typedData instanceof Int32Array) {
-        output = new Int32Array(outputSize);
-    }
-    else if (typedData instanceof Uint32Array) {
-        output = new Uint32Array(outputSize);
-    }
-    else if (typedData instanceof BigInt64Array) {
-        output = new BigInt64Array(outputSize);
-    }
-    else if (typedData instanceof BigUint64Array) {
-        output = new BigUint64Array(outputSize);
-    }
-    else if (typedData instanceof Float64Array) {
-        output = new Float64Array(outputSize);
-    }
-    else {
-        output = new Float32Array(outputSize);
-    }
-    // Calculate strides
-    const stride = calculateStride(shape);
-    const outputShape = shape.filter((_, i) => i !== cIndex);
-    const _outputStride = calculateStride(outputShape);
-    // Extract channel
-    const indices = new Array(shape.length).fill(0);
-    let outputIdx = 0;
-    for (let i = 0; i < outputSize; i++) {
-        // Set channel index
-        indices[cIndex] = channelIdx;
-        // Calculate source index
-        let sourceIdx = 0;
-        for (let j = 0; j < shape.length; j++) {
-            sourceIdx += indices[j] * stride[j];
-        }
-        output[outputIdx++] = typedData[sourceIdx];
-        // Increment indices (skip channel dimension)
-        for (let j = shape.length - 1; j >= 0; j--) {
-            if (j === cIndex)
-                continue;
-            indices[j]++;
-            if (indices[j] < shape[j])
-                break;
-            indices[j] = 0;
-        }
-    }
-    return output;
-}
-/**
- * Combine multiple channel arrays back into a single multi-channel array
- */
-async function combineChannels(channels, cIndex, _originalDims) {
-    // Read all channel data
-    const channelData = await Promise.all(channels.map((c) => zarr.get(c)));
-    // Determine combined shape
-    const firstChannel = channelData[0];
-    const channelShape = firstChannel.shape;
-    const combinedShape = [...channelShape];
-    combinedShape.splice(cIndex, 0, channels.length);
-    // Create combined array
-    const store = new Map();
-    const root = zarr.root(store);
-    const chunkShape = combinedShape.map((s) => Math.min(s, 256));
-    const dataType = getItkComponentType(firstChannel.data);
-    const combinedArray = await zarr.create(root.resolve("combined"), {
-        shape: combinedShape,
-        chunk_shape: chunkShape,
-        data_type: dataType,
-        fill_value: 0,
-    });
-    // Combine all channels
-    const totalSize = combinedShape.reduce((acc, s) => acc * s, 1);
-    let combined;
-    if (dataType === "uint8") {
-        combined = new Uint8Array(totalSize);
-    }
-    else if (dataType === "int8") {
-        combined = new Int8Array(totalSize);
-    }
-    else if (dataType === "int16") {
-        combined = new Int16Array(totalSize);
-    }
-    else if (dataType === "uint16") {
-        combined = new Uint16Array(totalSize);
-    }
-    else if (dataType === "int32") {
-        combined = new Int32Array(totalSize);
-    }
-    else if (dataType === "uint32") {
-        combined = new Uint32Array(totalSize);
-    }
-    else if (dataType === "int64") {
-        combined = new BigInt64Array(totalSize);
-    }
-    else if (dataType === "uint64") {
-        combined = new BigUint64Array(totalSize);
-    }
-    else if (dataType === "float64") {
-        combined = new Float64Array(totalSize);
-    }
-    else {
-        combined = new Float32Array(totalSize);
-    }
-    const stride = calculateStride(combinedShape);
-    const _channelStride = calculateStride(channelShape);
-    // Copy each channel's data
-    for (let c = 0; c < channels.length; c++) {
-        const channelTypedData = channelData[c].data;
-        const indices = new Array(combinedShape.length).fill(0);
-        for (let i = 0; i < channelTypedData.length; i++) {
-            // Set channel index
-            indices[cIndex] = c;
-            // Calculate target index in combined array
-            let targetIdx = 0;
-            for (let j = 0; j < combinedShape.length; j++) {
-                targetIdx += indices[j] * stride[j];
-            }
-            combined[targetIdx] = channelTypedData[i];
-            // Increment indices (skip channel dimension)
-            for (let j = combinedShape.length - 1; j >= 0; j--) {
-                if (j === cIndex)
-                    continue;
-                indices[j]++;
-                if (indices[j] < combinedShape[j])
-                    break;
-                indices[j] = 0;
-            }
-        }
-    }
-    // Write combined data
-    await zarr.set(combinedArray, [], {
-        data: combined,
-        shape: combinedShape,
-        stride,
-    });
-    return combinedArray;
-}
-/**
- * Perform Gaussian downsampling using ITK-Wasm
- */
-async function downsampleGaussian(image, dimFactors, spatialDims) {
-    const cIndex = image.dims.indexOf("c");
-    const isVector = cIndex === image.dims.length - 1;
-    const isChannelFirst = cIndex !== -1 && cIndex < image.dims.length - 1 &&
-        !isVector;
-    // If channel is first (before spatial dims), process each channel separately
-    if (isChannelFirst) {
-        return await downsampleChannelFirst(image, dimFactors, spatialDims, "gaussian");
-    }
-    // Convert to ITK-Wasm format
-    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
-    // Prepare shrink factors - need to be for spatial dimensions only
-    // For vector images, the last dimension (c) is NOT a spatial dimension in the ITK image
-    const shrinkFactors = [];
-    const effectiveDims = isVector ? image.dims.slice(0, -1) : image.dims;
-    for (let i = 0; i < effectiveDims.length; i++) {
-        const dim = effectiveDims[i];
-        if (SPATIAL_DIMS.includes(dim)) {
-            shrinkFactors.push(dimFactors[dim] || 1);
-        }
-        else {
-            shrinkFactors.push(1); // Non-spatial dimensions don't shrink
-        }
-    }
-    // Compute kernel radius - sigma should also be for ALL dimensions
-    const blockSize = itkImage.size.slice().reverse();
-    const sigma = computeSigma(shrinkFactors);
-    const { radius: _radius } = await (0, downsample_1.gaussianKernelRadiusNode)({
-        size: blockSize,
-        sigma,
-    });
-    // Perform downsampling
-    const { downsampled } = await (0, downsample_1.downsampleNode)(itkImage, {
-        shrinkFactors,
-        cropRadius: shrinkFactors.map(() => 0),
-    });
-    // Compute new metadata
-    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
-    // Convert back to zarr array
-    const chunkShape = downsampled.size.map((s) => Math.min(s, 256));
-    const array = await itkImageToZarr(downsampled, "downsampled", chunkShape);
-    return new ngff_image_js_1.NgffImage({
-        data: array,
-        dims: image.dims,
-        scale,
-        translation,
-        name: image.name,
-        axesUnits: image.axesUnits,
-        computedCallbacks: image.computedCallbacks,
-    });
-}
-/**
- * Perform bin shrink downsampling using ITK-Wasm
- */
-async function downsampleBinShrinkImpl(image, dimFactors, spatialDims) {
-    const cIndex = image.dims.indexOf("c");
-    const isVector = cIndex === image.dims.length - 1;
-    const isChannelFirst = cIndex !== -1 && cIndex < image.dims.length - 1 &&
-        !isVector;
-    // If channel is first (before spatial dims), process each channel separately
-    if (isChannelFirst) {
-        return await downsampleChannelFirst(image, dimFactors, spatialDims, "bin_shrink");
-    }
-    // Convert to ITK-Wasm format
-    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
-    // Prepare shrink factors - need to be for spatial dimensions only
-    // For vector images, the last dimension (c) is NOT a spatial dimension in the ITK image
-    const shrinkFactors = [];
-    const effectiveDims = isVector ? image.dims.slice(0, -1) : image.dims;
-    for (let i = 0; i < effectiveDims.length; i++) {
-        const dim = effectiveDims[i];
-        if (SPATIAL_DIMS.includes(dim)) {
-            shrinkFactors.push(dimFactors[dim] || 1);
-        }
-        else {
-            shrinkFactors.push(1); // Non-spatial dimensions don't shrink
-        }
-    }
-    // Perform downsampling
-    const { downsampled } = await (0, downsample_1.downsampleBinShrinkNode)(itkImage, {
-        shrinkFactors,
-    });
-    // Compute new metadata
-    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
-    // Convert back to zarr array
-    const chunkShape = downsampled.size.map((s) => Math.min(s, 256));
-    const array = await itkImageToZarr(downsampled, "downsampled", chunkShape);
-    return new ngff_image_js_1.NgffImage({
-        data: array,
-        dims: image.dims,
-        scale,
-        translation,
-        name: image.name,
-        axesUnits: image.axesUnits,
-        computedCallbacks: image.computedCallbacks,
-    });
-}
-/**
- * Perform label image downsampling using ITK-Wasm
- */
-async function downsampleLabelImageImpl(image, dimFactors, spatialDims) {
-    const cIndex = image.dims.indexOf("c");
-    const isVector = cIndex === image.dims.length - 1;
-    const isChannelFirst = cIndex !== -1 && cIndex < image.dims.length - 1 &&
-        !isVector;
-    // If channel is first (before spatial dims), process each channel separately
-    if (isChannelFirst) {
-        return await downsampleChannelFirst(image, dimFactors, spatialDims, "label_image");
-    }
-    // Convert to ITK-Wasm format
-    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
-    // Prepare shrink factors - need to be for spatial dimensions only
-    // For vector images, the last dimension (c) is NOT a spatial dimension in the ITK image
-    const shrinkFactors = [];
-    const effectiveDims = isVector ? image.dims.slice(0, -1) : image.dims;
-    for (let i = 0; i < effectiveDims.length; i++) {
-        const dim = effectiveDims[i];
-        if (SPATIAL_DIMS.includes(dim)) {
-            shrinkFactors.push(dimFactors[dim] || 1);
-        }
-        else {
-            shrinkFactors.push(1); // Non-spatial dimensions don't shrink
-        }
-    }
-    // Compute kernel radius
-    const blockSize = itkImage.size.slice().reverse();
-    const sigma = computeSigma(shrinkFactors);
-    const { radius: _radius } = await (0, downsample_1.gaussianKernelRadiusNode)({
-        size: blockSize,
-        sigma,
-    });
-    // Perform downsampling
-    const { downsampled } = await (0, downsample_1.downsampleLabelImageNode)(itkImage, {
-        shrinkFactors,
-        cropRadius: shrinkFactors.map(() => 0),
-    });
-    // Compute new metadata
-    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
-    // Convert back to zarr array
-    const chunkShape = downsampled.size.map((s) => Math.min(s, 256));
-    const array = await itkImageToZarr(downsampled, "downsampled", chunkShape);
-    return new ngff_image_js_1.NgffImage({
-        data: array,
-        dims: image.dims,
-        scale,
-        translation,
-        name: image.name,
-        axesUnits: image.axesUnits,
-        computedCallbacks: image.computedCallbacks,
-    });
-}
-/**
- * Main downsampling function for ITK-Wasm
- */
-async function downsampleItkWasm(ngffImage, scaleFactors, smoothing) {
-    const multiscales = [ngffImage];
-    let previousImage = ngffImage;
-    const dims = ngffImage.dims;
-    let previousDimFactors = {};
-    for (const dim of dims) {
-        previousDimFactors[dim] = 1;
-    }
-    const spatialDims = dims.filter((dim) => SPATIAL_DIMS.includes(dim));
-    for (const scaleFactor of scaleFactors) {
-        const dimFactors = dimScaleFactors(dims, scaleFactor, previousDimFactors);
-        previousDimFactors = updatePreviousDimFactors(scaleFactor, spatialDims, previousDimFactors);
-        let downsampled;
-        if (smoothing === "gaussian") {
-            downsampled = await downsampleGaussian(previousImage, dimFactors, spatialDims);
-        }
-        else if (smoothing === "bin_shrink") {
-            downsampled = await downsampleBinShrinkImpl(previousImage, dimFactors, spatialDims);
-        }
-        else if (smoothing === "label_image") {
-            downsampled = await downsampleLabelImageImpl(previousImage, dimFactors, spatialDims);
-        }
-        else {
-            throw new Error(`Unknown smoothing method: ${smoothing}`);
-        }
-        multiscales.push(downsampled);
-        previousImage = downsampled;
-    }
-    return multiscales;
-}
+ * For Deno runtime, we default to the node implementation.
+ * For browser bundlers, they should use conditional exports in package.json
+ * to resolve to the browser implementation.
+ */
+// Default to Node implementation for Deno and Node.js environments
+// Browser bundlers should use conditional exports to get itkwasm-browser.ts
+var itkwasm_node_js_1 = require("./itkwasm-node.js");
+Object.defineProperty(exports, "downsampleItkWasm", { enumerable: true, get: function () { return itkwasm_node_js_1.downsampleItkWasm; } });