@fideus-labs/ngff-zarr 0.2.0 → 0.2.1

package/esm/methods/itkwasm-node.js

@@ -0,0 +1,462 @@
+// SPDX-FileCopyrightText: Copyright (c) Fideus Labs LLC
+// SPDX-License-Identifier: MIT
+/**
+ * Node-compatible ITK-Wasm downsampling support
+ * Uses native WASM implementations from @itk-wasm/downsample
+ */
+import { downsampleBinShrinkNode as downsampleBinShrink, downsampleLabelImageNode as downsampleLabelImage, downsampleNode as downsample, } from "@itk-wasm/downsample";
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+import { dimScaleFactors, itkImageToZarr, nextScaleMetadata, SPATIAL_DIMS, updatePreviousDimFactors, zarrToItkImage, } from "./itkwasm-shared.js";
+/**
+ * Perform Gaussian downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleGaussian(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice (without 't', so no infinite loop)
+            const downsampledSlice = await downsampleGaussian(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata (time dimension unchanged, spatial dimensions downsampled)
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - need to be for ALL dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+    }
+    // Use all zeros for cropRadius
+    const cropRadius = new Array(shrinkFactors.length).fill(0);
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsample(itkImage, {
+        shrinkFactors,
+        cropRadius: cropRadius,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Perform bin shrink downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleBinShrinkImpl(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice
+            const downsampledSlice = await downsampleBinShrinkImpl(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - only for spatial dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+    }
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsampleBinShrink(itkImage, {
+        shrinkFactors,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Perform label image downsampling using ITK-Wasm (browser version)
+ */
+async function downsampleLabelImageImpl(image, dimFactors, spatialDims) {
+    // Handle time dimension by processing each time slice independently
+    if (image.dims.includes("t")) {
+        const tDimIndex = image.dims.indexOf("t");
+        const tSize = image.data.shape[tDimIndex];
+        const newDims = image.dims.filter((dim) => dim !== "t");
+        // Downsample each time slice
+        const downsampledSlices = [];
+        for (let t = 0; t < tSize; t++) {
+            // Extract time slice
+            const selection = new Array(image.data.shape.length).fill(null);
+            selection[tDimIndex] = t;
+            const sliceData = await zarr.get(image.data, selection);
+            // Create temporary zarr array for this slice
+            const sliceStore = new Map();
+            const sliceRoot = zarr.root(sliceStore);
+            const sliceShape = image.data.shape.filter((_, i) => i !== tDimIndex);
+            const sliceChunkShape = sliceShape.map((s) => Math.min(s, 256));
+            const sliceArray = await zarr.create(sliceRoot.resolve("slice"), {
+                shape: sliceShape,
+                chunk_shape: sliceChunkShape,
+                data_type: image.data.dtype,
+                fill_value: 0,
+            });
+            const fullSelection = new Array(sliceShape.length).fill(null);
+            await zarr.set(sliceArray, fullSelection, sliceData);
+            // Create NgffImage for this slice (without 't' dimension)
+            const sliceImage = new NgffImage({
+                data: sliceArray,
+                dims: newDims,
+                scale: Object.fromEntries(Object.entries(image.scale).filter(([dim]) => dim !== "t")),
+                translation: Object.fromEntries(Object.entries(image.translation).filter(([dim]) => dim !== "t")),
+                name: image.name,
+                axesUnits: image.axesUnits
+                    ? Object.fromEntries(Object.entries(image.axesUnits).filter(([dim]) => dim !== "t"))
+                    : undefined,
+                computedCallbacks: image.computedCallbacks,
+            });
+            // Recursively downsample this slice
+            const downsampledSlice = await downsampleLabelImageImpl(sliceImage, dimFactors, spatialDims);
+            downsampledSlices.push(downsampledSlice.data);
+        }
+        // Combine downsampled slices back into a single array with 't' dimension
+        const firstSlice = downsampledSlices[0];
+        const combinedShape = [...image.data.shape];
+        combinedShape[tDimIndex] = tSize;
+        // Update spatial dimensions based on downsampled size
+        for (let i = 0; i < image.dims.length; i++) {
+            if (i !== tDimIndex) {
+                const sliceIndex = i < tDimIndex ? i : i - 1;
+                combinedShape[i] = firstSlice.shape[sliceIndex];
+            }
+        }
+        // Create combined array
+        const combinedStore = new Map();
+        const combinedRoot = zarr.root(combinedStore);
+        const combinedArray = await zarr.create(combinedRoot.resolve("combined"), {
+            shape: combinedShape,
+            chunk_shape: combinedShape.map((s) => Math.min(s, 256)),
+            data_type: image.data.dtype,
+            fill_value: 0,
+        });
+        // Copy each downsampled slice into the combined array
+        for (let t = 0; t < tSize; t++) {
+            const sliceData = await zarr.get(downsampledSlices[t]);
+            const targetSelection = new Array(combinedShape.length).fill(null);
+            targetSelection[tDimIndex] = t;
+            await zarr.set(combinedArray, targetSelection, sliceData);
+        }
+        // Compute new metadata
+        const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+        return new NgffImage({
+            data: combinedArray,
+            dims: image.dims,
+            scale: { ...image.scale, ...scale },
+            translation: { ...image.translation, ...translation },
+            name: image.name,
+            axesUnits: image.axesUnits,
+            computedCallbacks: image.computedCallbacks,
+        });
+    }
+    const isVector = image.dims.includes("c");
+    // Convert to ITK-Wasm format
+    const itkImage = await zarrToItkImage(image.data, image.dims, isVector);
+    // Prepare shrink factors - need to be for ALL dimensions in ITK order (reversed)
+    const shrinkFactors = [];
+    for (let i = image.dims.length - 1; i >= 0; i--) {
+        const dim = image.dims[i];
+        if (SPATIAL_DIMS.includes(dim)) {
+            shrinkFactors.push(dimFactors[dim] || 1);
+        }
+        else {
+            shrinkFactors.push(1); // Non-spatial dimensions don't shrink
+        }
+    }
+    // Use all zeros for cropRadius
+    const cropRadius = new Array(shrinkFactors.length).fill(0);
+    // Perform downsampling using browser-compatible function
+    const { downsampled } = await downsampleLabelImage(itkImage, {
+        shrinkFactors,
+        cropRadius: cropRadius,
+    });
+    // Compute new metadata
+    const [translation, scale] = nextScaleMetadata(image, dimFactors, spatialDims);
+    // Convert back to zarr array in a new in-memory store
+    const store = new Map();
+    const chunkShape = downsampled.size.map((s) => Math.min(s, 256)).reverse();
+    const array = await itkImageToZarr(downsampled, store, "image", chunkShape, image.dims);
+    return new NgffImage({
+        data: array,
+        dims: image.dims,
+        scale,
+        translation,
+        name: image.name,
+        axesUnits: image.axesUnits,
+        computedCallbacks: image.computedCallbacks,
+    });
+}
+/**
+ * Main downsampling function for ITK-Wasm (browser version)
+ */
+export async function downsampleItkWasm(ngffImage, scaleFactors, smoothing) {
+    const multiscales = [ngffImage];
+    const dims = ngffImage.dims;
+    const spatialDims = dims.filter((dim) => SPATIAL_DIMS.includes(dim));
+    let previousImage = ngffImage;
+    let previousDimFactors = {};
+    for (const dim of dims)
+        previousDimFactors[dim] = 1;
+    for (let i = 0; i < scaleFactors.length; i++) {
+        const scaleFactor = scaleFactors[i];
+        let sourceImage;
+        let sourceDimFactors;
+        if (smoothing === "bin_shrink") {
+            // Purely incremental: scaleFactor is the shrink for this step
+            sourceImage = previousImage;
+            sourceDimFactors = {};
+            if (typeof scaleFactor === "number") {
+                for (const dim of spatialDims)
+                    sourceDimFactors[dim] = scaleFactor;
+            }
+            else {
+                for (const dim of spatialDims) {
+                    sourceDimFactors[dim] = scaleFactor[dim] || 1;
+                }
+            }
+            for (const dim of dims) {
+                if (!(dim in sourceDimFactors))
+                    sourceDimFactors[dim] = 1;
+            }
+        }
+        else {
+            // Hybrid absolute strategy
+            const dimFactors = dimScaleFactors(dims, scaleFactor, previousDimFactors, ngffImage, previousImage);
+            let canDownsampleIncrementally = true;
+            for (const dim of Object.keys(dimFactors)) {
+                const dimIndex = ngffImage.dims.indexOf(dim);
+                if (dimIndex >= 0) {
+                    const originalSize = ngffImage.data.shape[dimIndex];
+                    const targetSize = Math.floor(originalSize /
+                        (typeof scaleFactor === "number"
+                            ? scaleFactor
+                            : scaleFactor[dim]));
+                    const prevDimIndex = previousImage.dims.indexOf(dim);
+                    const previousSize = previousImage.data.shape[prevDimIndex];
+                    if (Math.floor(previousSize / dimFactors[dim]) !== targetSize) {
+                        canDownsampleIncrementally = false;
+                        break;
+                    }
+                }
+            }
+            if (canDownsampleIncrementally) {
+                sourceImage = previousImage;
+                sourceDimFactors = dimFactors;
+            }
+            else {
+                sourceImage = ngffImage;
+                const originalDimFactors = {};
+                for (const dim of dims)
+                    originalDimFactors[dim] = 1;
+                sourceDimFactors = dimScaleFactors(dims, scaleFactor, originalDimFactors);
+            }
+        }
+        let downsampled;
+        if (smoothing === "gaussian") {
+            downsampled = await downsampleGaussian(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else if (smoothing === "bin_shrink") {
+            downsampled = await downsampleBinShrinkImpl(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else if (smoothing === "label_image") {
+            downsampled = await downsampleLabelImageImpl(sourceImage, sourceDimFactors, spatialDims);
+        }
+        else {
+            throw new Error(`Unknown smoothing method: ${smoothing}`);
+        }
+        multiscales.push(downsampled);
+        previousImage = downsampled;
+        if (smoothing === "bin_shrink") {
+            if (typeof scaleFactor === "number") {
+                for (const dim of spatialDims) {
+                    previousDimFactors[dim] *= scaleFactor;
+                }
+            }
+            else {
+                for (const dim of spatialDims) {
+                    previousDimFactors[dim] *= scaleFactor[dim] || 1;
+                }
+            }
+        }
+        else {
+            previousDimFactors = updatePreviousDimFactors(scaleFactor, spatialDims, previousDimFactors);
+        }
+    }
+    return multiscales;
+}

package/esm/methods/itkwasm-shared.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Shared helper functions for ITK-Wasm downsampling
+ * Used by both browser and Node implementations
+ */
+import type { Image } from "itk-wasm";
+import * as zarr from "zarrita";
+import { NgffImage } from "../types/ngff_image.js";
+export declare const SPATIAL_DIMS: string[];
+export interface DimFactors {
+    [key: string]: number;
+}
+/**
+ * Calculate the incremental factor needed to reach the target size from the previous size.
+ * This ensures exact target sizes when downsampling incrementally.
+ */
+export declare function calculateIncrementalFactor(previousSize: number, targetSize: number): number;
+/**
+ * Convert dimension scale factors to ITK-Wasm format
+ * This computes the incremental scale factor relative to the previous scale,
+ * not the absolute scale factor from the original image.
+ *
+ * When originalImage and previousImage are provided, calculates the exact
+ * incremental factor needed to reach the target size from the previous size.
+ * This ensures we get exact 1x, 2x, 3x, 4x sizes even with incremental downsampling.
+ */
+export declare function dimScaleFactors(dims: string[], scaleFactor: Record<string, number> | number, previousDimFactors: DimFactors, originalImage?: NgffImage, previousImage?: NgffImage): DimFactors;
+/**
+ * Update previous dimension factors
+ */
+export declare function updatePreviousDimFactors(scaleFactor: Record<string, number> | number, spatialDims: string[], previousDimFactors: DimFactors): DimFactors;
+/**
+ * Compute next scale metadata
+ */
+export declare function nextScaleMetadata(image: NgffImage, dimFactors: DimFactors, spatialDims: string[]): [Record<string, number>, Record<string, number>];
+/**
+ * Get ITK component type from typed array
+ */
+export declare function getItkComponentType(data: unknown): "uint8" | "int8" | "uint16" | "int16" | "uint32" | "int32" | "float32" | "float64";
+/**
+ * Create identity matrix for ITK direction
+ */
+export declare function createIdentityMatrix(dimension: number): Float64Array;
+/**
+ * Transpose array data according to permutation
+ */
+export declare function transposeArray(data: unknown, shape: number[], permutation: number[], componentType: "uint8" | "int8" | "uint16" | "int16" | "uint32" | "int32" | "float32" | "float64"): Float32Array | Float64Array | Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array;
+/**
+ * Convert zarr array to ITK-Wasm Image format
+ * If isVector is true, ensures "c" dimension is last by transposing if needed
+ */
+export declare function zarrToItkImage(array: zarr.Array<zarr.DataType, zarr.Readable>, dims: string[], isVector?: boolean): Promise<Image>;
+/**
+ * Convert ITK-Wasm Image back to zarr array
+ * Uses the provided store instead of creating a new one
+ *
+ * Important: ITK-Wasm stores size in physical space order [x, y, z], but data in
+ * column-major order (x contiguous). This column-major layout with size [x, y, z]
+ * is equivalent to C-order (row-major) with shape [z, y, x]. We reverse the size
+ * to get the zarr shape and use C-order strides for that reversed shape.
+ *
+ * @param itkImage - The ITK-Wasm image to convert
+ * @param store - The zarr store to write to
+ * @param path - The path within the store
+ * @param chunkShape - The chunk shape (in spatial dimension order, will be adjusted for components)
+ * @param targetDims - The target dimension order (e.g., ["c", "z", "y", "x"])
+ */
+export declare function itkImageToZarr(itkImage: Image, store: Map<string, Uint8Array>, path: string, chunkShape: number[], targetDims?: string[]): Promise<zarr.Array<zarr.DataType, zarr.Readable>>;
+//# sourceMappingURL=itkwasm-shared.d.ts.map

package/esm/methods/itkwasm-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itkwasm-shared.d.ts","sourceRoot":"","sources":["../../src/methods/itkwasm-shared.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD,eAAO,MAAM,YAAY,UAAkB,CAAC;AAE5C,MAAM,WAAW,UAAU;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,MAAM,CAsBR;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAC5C,kBAAkB,EAAE,UAAU,EAC9B,aAAa,CAAC,EAAE,SAAS,EACzB,aAAa,CAAC,EAAE,SAAS,GACxB,UAAU,CAqEZ;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAC5C,WAAW,EAAE,MAAM,EAAE,EACrB,kBAAkB,EAAE,UAAU,GAC7B,UAAU,CAcZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,MAAM,EAAE,GACpB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAkBlD;AAsCD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,GAEX,OAAO,GACP,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,CASZ;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAMpE;AAcD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,MAAM,EAAE,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,aAAa,EACT,OAAO,GACP,MAAM,GACN,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,SAAS,GAEX,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,SAAS,GACT,WAAW,GACX,UAAU,GACV,WAAW,GACX,UAAU,CAqFb;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EAC/C,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,UAAQ,GACf,OAAO,CAAC,KAAK,CAAC,CAqFhB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,KAAK,EACf,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAC9B,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAAE,EACpB,UAAU,CAAC,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAoJnD"}