@alleninstitute/vis-omezarr 0.0.17

package/dist/module.js

@@ -0,0 +1,969 @@
+import {intervalToVec2 as $7soKB$intervalToVec2, Box2D as $7soKB$Box2D, Vec2 as $7soKB$Vec2, limit as $7soKB$limit} from "@alleninstitute/vis-geometry";
+import {logger as $7soKB$logger, buildAsyncRenderer as $7soKB$buildAsyncRenderer, getResourceUrl as $7soKB$getResourceUrl, VisError as $7soKB$VisError, makeRGBAColorVector as $7soKB$makeRGBAColorVector} from "@alleninstitute/vis-core";
+import {FetchStore as $7soKB$FetchStore, open as $7soKB$open, root as $7soKB$root, slice as $7soKB$slice, get as $7soKB$get} from "zarrita";
+import {ZodError as $7soKB$ZodError, z as $7soKB$z} from "zod";
+
+
+
+
+
+
+
+class $8af220877f5aad67$export$96bea966bad52d02 extends (0, $7soKB$VisError) {
+}
+class $8af220877f5aad67$export$e819e674f1e05236 extends $8af220877f5aad67$export$96bea966bad52d02 {
+}
+class $8af220877f5aad67$export$d7f857358a0dbda6 extends $8af220877f5aad67$export$96bea966bad52d02 {
+}
+
+
+
+
+
+// these dimension indices are given for a 4-element shape array
+const $0ff6a7cfdd9baaf1$var$SHAPE_Z_DIM_INDEX = 1;
+const $0ff6a7cfdd9baaf1$var$SHAPE_Y_DIM_INDEX = 2;
+const $0ff6a7cfdd9baaf1$var$SHAPE_X_DIM_INDEX = 3;
+const $0ff6a7cfdd9baaf1$export$9989519d74cf4fd0 = (0, $7soKB$z).object({
+    name: (0, $7soKB$z).string().toLowerCase(),
+    type: (0, $7soKB$z).string(),
+    scale: (0, $7soKB$z).number().optional(),
+    unit: (0, $7soKB$z).string().optional()
+});
+const $0ff6a7cfdd9baaf1$export$13526d3947c5c7c2 = (0, $7soKB$z).object({
+    translation: (0, $7soKB$z).number().array().min(4).max(5),
+    type: (0, $7soKB$z).literal('translation')
+});
+const $0ff6a7cfdd9baaf1$export$f0f448c9214bb1a1 = (0, $7soKB$z).object({
+    scale: (0, $7soKB$z).number().array().min(4).max(5),
+    type: (0, $7soKB$z).literal('scale')
+});
+const $0ff6a7cfdd9baaf1$export$2e1c7be8e43a67e3 = (0, $7soKB$z).discriminatedUnion('type', [
+    $0ff6a7cfdd9baaf1$export$13526d3947c5c7c2,
+    $0ff6a7cfdd9baaf1$export$f0f448c9214bb1a1
+]);
+const $0ff6a7cfdd9baaf1$export$a535e1d8aa90b3c9 = (0, $7soKB$z).object({
+    coordinateTransformations: $0ff6a7cfdd9baaf1$export$2e1c7be8e43a67e3.array().nonempty(),
+    path: (0, $7soKB$z).string()
+});
+const $0ff6a7cfdd9baaf1$export$d7d6a65692bb1dc0 = (0, $7soKB$z).object({
+    name: (0, $7soKB$z).string(),
+    version: (0, $7soKB$z).string().optional(),
+    type: (0, $7soKB$z).string().optional(),
+    axes: $0ff6a7cfdd9baaf1$export$9989519d74cf4fd0.array().nonempty(),
+    datasets: $0ff6a7cfdd9baaf1$export$a535e1d8aa90b3c9.array().nonempty()
+});
+const $0ff6a7cfdd9baaf1$export$90729eda236ba57 = (0, $7soKB$z).object({
+    min: (0, $7soKB$z).number(),
+    start: (0, $7soKB$z).number(),
+    end: (0, $7soKB$z).number(),
+    max: (0, $7soKB$z).number()
+});
+const $0ff6a7cfdd9baaf1$export$bb4e42bb52e6d21d = (0, $7soKB$z).object({
+    active: (0, $7soKB$z).boolean().optional(),
+    color: (0, $7soKB$z).string(),
+    label: (0, $7soKB$z).string().optional(),
+    window: $0ff6a7cfdd9baaf1$export$90729eda236ba57
+});
+const $0ff6a7cfdd9baaf1$export$51e803dddccc5479 = (0, $7soKB$z).object({
+    channels: $0ff6a7cfdd9baaf1$export$bb4e42bb52e6d21d.array().nonempty()
+});
+const $0ff6a7cfdd9baaf1$export$fd8824855129d20 = (0, $7soKB$z).object({
+    multiscales: $0ff6a7cfdd9baaf1$export$d7d6a65692bb1dc0.array().nonempty(),
+    omero: $0ff6a7cfdd9baaf1$export$51e803dddccc5479.optional()
+});
+const $0ff6a7cfdd9baaf1$export$abb89b3cbbc08888 = $0ff6a7cfdd9baaf1$export$fd8824855129d20;
+const $0ff6a7cfdd9baaf1$export$4a10f5b26a59ff84 = (0, $7soKB$z).object({
+    ome: $0ff6a7cfdd9baaf1$export$fd8824855129d20
+});
+const $0ff6a7cfdd9baaf1$export$a3b48a0a4f3d252 = (0, $7soKB$z).union([
+    $0ff6a7cfdd9baaf1$export$abb89b3cbbc08888,
+    $0ff6a7cfdd9baaf1$export$4a10f5b26a59ff84
+]).transform((v)=>{
+    if ('ome' in v) return {
+        zarrVersion: 3,
+        ...v.ome
+    };
+    return {
+        zarrVersion: 2,
+        ...v
+    };
+});
+function $0ff6a7cfdd9baaf1$export$ac32486ec3a6add8(omero) {
+    return omero.channels.map($0ff6a7cfdd9baaf1$export$9b3c6a55077c31a1);
+}
+function $0ff6a7cfdd9baaf1$export$9b3c6a55077c31a1(omeroChannel) {
+    const active = omeroChannel.active;
+    const label = omeroChannel.label;
+    const rgba = (0, $7soKB$makeRGBAColorVector)(omeroChannel.color);
+    const rgb = [
+        rgba[0],
+        rgba[1],
+        rgba[2]
+    ];
+    const { min: winMin, max: winMax } = omeroChannel.window;
+    const { start: ranMin, end: ranMax } = omeroChannel.window;
+    const window = {
+        min: winMin,
+        max: winMax
+    };
+    const range = {
+        min: ranMin,
+        max: ranMax
+    };
+    return {
+        rgb: rgb,
+        rgba: rgba,
+        window: window,
+        range: range,
+        active: active,
+        label: label
+    };
+}
+class $0ff6a7cfdd9baaf1$export$c7c266bed5c41e68 {
+    #url;
+    #attrs;
+    #arrays;
+    #zarrVersion;
+    constructor(url, attrs, arrays, zarrVersion){
+        this.#url = url;
+        this.#attrs = attrs;
+        this.#arrays = arrays;
+        this.#zarrVersion = zarrVersion;
+    }
+    get url() {
+        return this.#url;
+    }
+    get attrs() {
+        return this.#attrs;
+    }
+    get arrays() {
+        return this.#arrays;
+    }
+    get zarrVersion() {
+        return this.#zarrVersion;
+    }
+    toJSON() {
+        return {
+            url: this.url,
+            attrs: this.attrs,
+            arrays: this.arrays,
+            zarrVersion: this.zarrVersion,
+            colorChannels: this.colorChannels,
+            redChannel: this.redChannel,
+            blueChannel: this.blueChannel,
+            greenChannel: this.greenChannel
+        };
+    }
+    #getMultiscaleIndex(multiscale) {
+        if (multiscale !== undefined) {
+            if (typeof multiscale === 'number') {
+                if (multiscale < 0) return -1;
+                return multiscale;
+            }
+            return this.#attrs.multiscales.findIndex((m)=>m.name === multiscale);
+        }
+        return 0;
+    }
+    #getValidMultiscaleIndex(multiscale) {
+        const multiscaleIndex = this.#getMultiscaleIndex(multiscale);
+        if (multiscaleIndex < 0) {
+            const message = `invalid multiscale requested: identifier [${multiscale}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$d7f857358a0dbda6)(message);
+        }
+        return multiscaleIndex;
+    }
+    #getDatasetIndex(dataset, multiscaleIndex) {
+        const datasets = this.#attrs.multiscales[multiscaleIndex]?.datasets ?? null;
+        if (!datasets) return -1;
+        if (typeof dataset === 'number') {
+            if (dataset < 0 || dataset >= datasets.length) return -1;
+            return dataset;
+        }
+        return datasets.findIndex((d)=>d.path === dataset);
+    }
+    #getValidDatasetIndex(dataset, multiscaleIndex) {
+        const datasetIndex = this.#getDatasetIndex(dataset, multiscaleIndex);
+        if (datasetIndex < 0) {
+            const message = `invalid dataset requested: identifier [${dataset}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$d7f857358a0dbda6)(message);
+        }
+        return datasetIndex;
+    }
+    /** Private function that retrieves the X value from the `shape` of a given array, within a
+     * specific multiscale representation of the data.
+     */ #getShapeX(array, multiscaleIndex) {
+        const shape = array.shape;
+        if (!shape || shape.length < 4) {
+            const message = `invalid dataset: .zarray formatting invalid, found array without valid shape; path [${multiscaleIndex}/${array.path}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+        }
+        const shapeIndex = shape.length === 5 ? $0ff6a7cfdd9baaf1$var$SHAPE_X_DIM_INDEX + 1 : $0ff6a7cfdd9baaf1$var$SHAPE_X_DIM_INDEX;
+        return shape[shapeIndex];
+    }
+    /** Private function that retrieves the Y value from the `shape` of a given array, within a
+     * specific multiscale representation of the data.
+     */ #getShapeY(array, multiscaleIndex) {
+        const shape = array.shape;
+        if (!shape || shape.length < 4) {
+            const message = `invalid dataset: .zarray formatting invalid, found array without valid shape; path [${multiscaleIndex}/${array.path}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+        }
+        const shapeIndex = shape.length === 5 ? $0ff6a7cfdd9baaf1$var$SHAPE_Y_DIM_INDEX + 1 : $0ff6a7cfdd9baaf1$var$SHAPE_Y_DIM_INDEX;
+        return shape[shapeIndex];
+    }
+    /** Private function that retrieves the Z value from the `shape` of a given array, within a
+     * specific multiscale representation of the data.
+     */ #getShapeZ(array, multiscaleIndex) {
+        const shape = array.shape;
+        if (!shape || shape.length < 4) {
+            const message = `invalid dataset: .zarray formatting invalid, found array without valid shape; path [${multiscaleIndex}/${array.path}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+        }
+        // This checks to see if the shape provided has all 5 official OME-Zarr dimensions (t, c, z, y, x),
+        // or just the 4 that we typically have in our data files (c, z, y, x)
+        const shapeIndex = shape.length === 5 ? $0ff6a7cfdd9baaf1$var$SHAPE_Z_DIM_INDEX + 1 : $0ff6a7cfdd9baaf1$var$SHAPE_Z_DIM_INDEX;
+        return shape[shapeIndex];
+    }
+    /** Private function to retrieve the maximum value for a given shape element, e.g.
+     * the maximum value of one of the dimensions (t, c, z, y, x). It compares across all
+     * the values of that dimension for all zarrays/datasets within a given multiscale
+     * representation of the data.
+     *
+     * Note: Typically, we only receive the last 4 elements in the `shape` of a zarray.
+     *
+     * @param getShapeElement a function that retrieves one element from the `shape` of
+     * a zarray
+     * @returns the maxium value of that element across all arrays within the given
+     * multiscale representation
+     */ #getShapeElementMax(getShapeElement, multiscale) {
+        const multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+        return this.#attrs.multiscales[multiscaleIndex].datasets.map((dataset)=>{
+            const array = this.#arrays.find((a)=>a.path === dataset.path);
+            if (!array) {
+                const message = `invalid dataset: .zarray missing for dataset [${multiscaleIndex}/${dataset.path}]`;
+                (0, $7soKB$logger).error(message);
+                throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+            }
+            return getShapeElement(array, multiscaleIndex);
+        }).reduce((prev, curr)=>Math.max(prev, curr));
+    }
+    /**
+     * Given a specific @param multiscale representation of the Zarr data, finds the
+     * largest X shape component among the shapes of the different dataset arrays.
+     * @param multiscale the index or path of a specific multiscale representation (defaults to 0)
+     * @returns the largest Z scale for the specified multiscale representation
+     */ maxX(multiscale = 0) {
+        return this.#getShapeElementMax(this.#getShapeX, multiscale);
+    }
+    /**
+     * Given a specific @param multiscale representation of the Zarr data, finds the
+     * largest Y shape component among the shapes of the different dataset arrays.
+     * @param multiscale the index or path of a specific multiscale representation (defaults to 0)
+     * @returns the largest Z scale for the specified multiscale representation
+     */ maxY(multiscale = 0) {
+        return this.#getShapeElementMax(this.#getShapeY, multiscale);
+    }
+    /**
+     * Given a specific @param multiscale representation of the Zarr data, finds the
+     * largest Z shape component among the shapes of the different dataset arrays.
+     * @param multiscale the index or path of a specific multiscale representation (defaults to 0)
+     * @returns the largest Z scale for the specified multiscale representation
+     */ maxZ(multiscale = 0) {
+        return this.#getShapeElementMax(this.#getShapeZ, multiscale);
+    }
+    maxOrthogonal(plane, multiscale = 0) {
+        if (plane.ortho === 'x') return this.maxX(multiscale);
+        if (plane.ortho === 'y') return this.maxY(multiscale);
+        if (plane.ortho === 'z') return this.maxZ(multiscale);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(`invalid plane: ortho set to '${plane.ortho}'`);
+    }
+    #makeShapedDataset(dataset, multiscaleIndex, datasetIndex) {
+        const array = this.#arrays.find((a)=>a.path === dataset.path);
+        if (!array) {
+            const message = `invalid dataset: .zarray missing for dataset [${multiscaleIndex}][${datasetIndex}]`;
+            (0, $7soKB$logger).error(message);
+            throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+        }
+        return {
+            ...dataset,
+            shape: array.shape,
+            multiscaleIndex: multiscaleIndex,
+            datasetIndex: datasetIndex
+        };
+    }
+    getShapedDataset(indexOrPath, multiscale = 0) {
+        try {
+            const multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+            const datasetIndex = this.#getValidDatasetIndex(indexOrPath, multiscaleIndex);
+            const dataset = this.#attrs.multiscales[multiscaleIndex].datasets[datasetIndex];
+            return this.#makeShapedDataset(dataset, multiscaleIndex, datasetIndex);
+        } catch (e) {
+            if (e instanceof (0, $8af220877f5aad67$export$d7f857358a0dbda6)) {
+                (0, $7soKB$logger).debug('encountered index error when retrieving shaped dataset; returning undefined');
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    getFirstShapedDataset(multiscale = 0) {
+        let multiscaleIndex;
+        try {
+            multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+            const dataset = this.#attrs.multiscales[multiscaleIndex].datasets[0];
+            return this.#makeShapedDataset(dataset, multiscaleIndex, 0);
+        } catch (e) {
+            if (e instanceof (0, $8af220877f5aad67$export$d7f857358a0dbda6)) {
+                (0, $7soKB$logger).debug('encountered index error when retrieving shaped dataset; returning undefined');
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    getLastShapedDataset(multiscale = 0) {
+        let multiscaleIndex;
+        try {
+            multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+            const datasets = this.#attrs.multiscales[multiscaleIndex].datasets;
+            const dataset = datasets[datasets.length - 1];
+            return this.#makeShapedDataset(dataset, multiscaleIndex, 0);
+        } catch (e) {
+            if (e instanceof (0, $8af220877f5aad67$export$d7f857358a0dbda6)) {
+                (0, $7soKB$logger).debug('encountered index error when retrieving shaped dataset; returning undefined');
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    getNumLayers(multiscale = 0) {
+        const multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+        return this.#attrs.multiscales[multiscaleIndex].datasets.length;
+    }
+    getAllShapedDatasets(multiscale = 0) {
+        const multiscaleIndex = this.#getValidMultiscaleIndex(multiscale);
+        const datasets = this.#attrs.multiscales[multiscaleIndex].datasets;
+        return datasets.map((dataset, i)=>this.#makeShapedDataset(dataset, multiscaleIndex, i));
+    }
+    dehydrate() {
+        return {
+            url: this.#url,
+            attrs: this.#attrs,
+            arrays: [
+                ...this.#arrays
+            ],
+            zarrVersion: this.#zarrVersion
+        };
+    }
+    static async rehydrate(dehydrated) {
+        const { url: url, attrs: attrs, arrays: arrays, zarrVersion: zarrVersion } = dehydrated;
+        return new $0ff6a7cfdd9baaf1$export$c7c266bed5c41e68(url, attrs, arrays, zarrVersion);
+    }
+    #getChannelByMask(colorMask) {
+        if (!this.#attrs.omero || !this.#attrs.omero.channels) {
+            (0, $7soKB$logger).debug(`no omero data found for color mask ${colorMask}, returning undefined`);
+            return undefined;
+        }
+        const omeroChannel = this.#attrs.omero.channels.find((ch)=>ch.color === colorMask);
+        if (!omeroChannel) {
+            (0, $7soKB$logger).debug(`no matching omero channel found for color mask ${colorMask}, returning undefined`);
+            return undefined;
+        }
+        return $0ff6a7cfdd9baaf1$export$9b3c6a55077c31a1(omeroChannel);
+    }
+    get colorChannels() {
+        return this.#attrs.omero ? $0ff6a7cfdd9baaf1$export$ac32486ec3a6add8(this.#attrs.omero) : [];
+    }
+    get redChannel() {
+        return this.#getChannelByMask('#FF0000');
+    }
+    get greenChannel() {
+        return this.#getChannelByMask('#00FF00');
+    }
+    get blueChannel() {
+        return this.#getChannelByMask('#0000FF');
+    }
+}
+
+
+
+
+async function $62574ebf548584b6$export$78b8536ed7d8a60d(res) {
+    const url = (0, $7soKB$getResourceUrl)(res);
+    const store = new $7soKB$FetchStore(url);
+    return $62574ebf548584b6$var$loadZarrAttrsFileFromStore(store);
+}
+async function $62574ebf548584b6$var$loadZarrAttrsFileFromStore(store) {
+    const group = await $7soKB$open(store, {
+        kind: 'group'
+    });
+    try {
+        return (0, $0ff6a7cfdd9baaf1$export$a3b48a0a4f3d252).parse(group.attrs);
+    } catch (e) {
+        if (e instanceof (0, $7soKB$ZodError)) (0, $7soKB$logger).error('could not load Zarr file: parsing failed');
+        throw e;
+    }
+}
+async function $62574ebf548584b6$export$7f36aeab32ab33f7(res, path, version = 2, loadV2Attrs = true) {
+    const url = (0, $7soKB$getResourceUrl)(res);
+    const store = new $7soKB$FetchStore(url);
+    const result = await $62574ebf548584b6$var$loadZarrArrayFileFromStore(store, path, version, loadV2Attrs);
+    return result.metadata;
+}
+async function $62574ebf548584b6$var$loadZarrArrayFileFromStore(store, path, version = 2, loadV2Attrs = true) {
+    const root = $7soKB$root(store);
+    let array;
+    if (version === 3) array = await $7soKB$open.v3(root.resolve(path), {
+        kind: 'array'
+    });
+    else if (version === 2) array = await $7soKB$open.v2(root.resolve(path), {
+        kind: 'array',
+        attrs: loadV2Attrs
+    });
+    else {
+        const message = `unsupported Zarr format version specified: ${version}`;
+        (0, $7soKB$logger).error(message);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+    }
+    const { shape: shape, attrs: attrs } = array;
+    try {
+        return {
+            metadata: {
+                path: path,
+                shape: shape,
+                attrs: attrs
+            },
+            raw: array
+        };
+    } catch (e) {
+        if (e instanceof (0, $7soKB$ZodError)) (0, $7soKB$logger).error('could not load Zarr file: parsing failed');
+        throw e;
+    }
+}
+async function $62574ebf548584b6$export$7999b0bb51b3dcb8(res, loadV2ArrayAttrs = true) {
+    const url = (0, $7soKB$getResourceUrl)(res);
+    const store = new $7soKB$FetchStore(url);
+    const attrs = await $62574ebf548584b6$var$loadZarrAttrsFileFromStore(store);
+    const version = attrs.zarrVersion;
+    const arrays = await Promise.all(attrs.multiscales.map((multiscale)=>{
+        return multiscale.datasets?.map(async (dataset)=>{
+            return (await $62574ebf548584b6$var$loadZarrArrayFileFromStore(store, dataset.path, version, loadV2ArrayAttrs)).metadata;
+        }) ?? [];
+    }).reduce((prev, curr)=>prev.concat(curr)).filter((v)=>v !== undefined));
+    return new (0, $0ff6a7cfdd9baaf1$export$c7c266bed5c41e68)(url, attrs, arrays, version);
+}
+function $62574ebf548584b6$export$8efeb0367ee93033(zarr, plane, relativeView, displayResolution) {
+    const datasets = zarr.getAllShapedDatasets(0);
+    const axes = zarr.attrs.multiscales[0].axes;
+    const firstDataset = datasets[0];
+    if (!firstDataset) {
+        const message = 'invalid Zarr data: no datasets found';
+        (0, $7soKB$logger).error(message);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+    }
+    const realSize = $62574ebf548584b6$export$c5890dae76bd0ad7(plane, axes, firstDataset);
+    if (!realSize) {
+        const message = 'invalid Zarr data: could not determine the size of the plane in the given units';
+        (0, $7soKB$logger).error(message);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+    }
+    const vxlPitch = (size)=>(0, $7soKB$Vec2).div(realSize, size);
+    // size, in dataspace, of a pixel 1/res
+    const pxPitch = (0, $7soKB$Vec2).div((0, $7soKB$Box2D).size(relativeView), displayResolution);
+    const dstToDesired = (a, goal)=>{
+        const diff = (0, $7soKB$Vec2).sub(a, goal);
+        if (diff[0] * diff[1] > 0) // the res (a) is higher than our goal -
+        // weight this heavily to prefer smaller than the goal
+        return 1000 * (0, $7soKB$Vec2).length((0, $7soKB$Vec2).sub(a, goal));
+        return (0, $7soKB$Vec2).length((0, $7soKB$Vec2).sub(a, goal));
+    };
+    // we assume the datasets are ordered... hmmm TODO
+    const choice = datasets.reduce((bestSoFar, cur)=>{
+        const planeSizeBest = $62574ebf548584b6$export$ba17f86721d4d0ce(plane, axes, bestSoFar);
+        const planeSizeCur = $62574ebf548584b6$export$ba17f86721d4d0ce(plane, axes, cur);
+        if (!planeSizeBest || !planeSizeCur) return bestSoFar;
+        return dstToDesired(vxlPitch(planeSizeBest), pxPitch) > dstToDesired(vxlPitch(planeSizeCur), pxPitch) ? cur : bestSoFar;
+    }, datasets[0]);
+    return choice ?? datasets[datasets.length - 1];
+}
+// TODO this is a duplicate of indexOfDimension... delete one of them!
+function $62574ebf548584b6$var$indexFor(dim, axes) {
+    return axes.findIndex((axis)=>axis.name === dim);
+}
+function $62574ebf548584b6$export$81eb4b4b765d519(layer, axes, parameter, dim) {
+    const dimIndex = $62574ebf548584b6$var$indexFor(dim, axes);
+    return Math.floor(layer.shape[dimIndex] * Math.max(0, Math.min(1, parameter)));
+}
+function $62574ebf548584b6$export$ca023b1dd6252668(zarr, plane, relativeView, displayResolution) {
+    // figure out what layer we'd be viewing
+    const layer = $62574ebf548584b6$export$8efeb0367ee93033(zarr, plane, relativeView, displayResolution);
+    const axes = zarr.attrs.multiscales[0].axes;
+    const slices = $62574ebf548584b6$export$fcb1a44ca126ee5c(plane.ortho, axes, layer);
+    return slices === undefined ? undefined : 1 / slices;
+}
+function $62574ebf548584b6$export$c5890dae76bd0ad7(plane, axes, dataset) {
+    const vxls = $62574ebf548584b6$export$ba17f86721d4d0ce(plane, axes, dataset);
+    if (vxls === undefined) return undefined;
+    let size = vxls;
+    // now, just apply the correct transforms, if they exist...
+    for (const trn of dataset.coordinateTransformations)if (trn.type === 'scale') {
+        // try to apply it!
+        const uIndex = $62574ebf548584b6$var$indexFor(plane.u, axes);
+        const vIndex = $62574ebf548584b6$var$indexFor(plane.v, axes);
+        size = (0, $7soKB$Vec2).mul(size, [
+            trn.scale[uIndex],
+            trn.scale[vIndex]
+        ]);
+    }
+    return size;
+}
+function $62574ebf548584b6$export$fcb1a44ca126ee5c(dim, axes, dataset) {
+    const uI = $62574ebf548584b6$var$indexFor(dim, axes);
+    if (uI === -1) return undefined;
+    return dataset.shape[uI];
+}
+function $62574ebf548584b6$export$ba17f86721d4d0ce(plane, axes, dataset) {
+    // first - u&v must not refer to the same dimension,
+    // and both should exist in the axes...
+    if (!plane.isValid()) return undefined;
+    const uI = $62574ebf548584b6$var$indexFor(plane.u, axes);
+    const vI = $62574ebf548584b6$var$indexFor(plane.v, axes);
+    if (uI === -1 || vI === -1) return undefined;
+    return [
+        dataset.shape[uI],
+        dataset.shape[vI]
+    ];
+}
+// feel free to freak out if the request is over or under determined or whatever
+function $62574ebf548584b6$var$buildQuery(r, axes, shape) {
+    const ordered = axes.map((a)=>r[a.name]);
+    // if any are undefined, throw up
+    if (ordered.some((a)=>a === undefined)) throw new (0, $8af220877f5aad67$export$e819e674f1e05236)('request does not match expected dimensions of OME-Zarr dataset');
+    return ordered.map((d, i)=>{
+        const bounds = {
+            min: 0,
+            max: shape[i]
+        };
+        if (d === null) return d;
+        if (typeof d === 'number') return (0, $7soKB$limit)(bounds, d);
+        return $7soKB$slice((0, $7soKB$limit)(bounds, d.min), (0, $7soKB$limit)(bounds, d.max));
+    });
+}
+async function $62574ebf548584b6$export$151d38946e654182(z) {
+    (0, $7soKB$logger).dir(z);
+}
+async function $62574ebf548584b6$export$831e2eeffaa681(metadata, r, level, signal) {
+    // put the request in native order
+    const store = new $7soKB$FetchStore(metadata.url);
+    const scene = metadata.attrs.multiscales[0];
+    const { axes: axes } = scene;
+    if (!level) {
+        const message = 'invalid Zarr data: no datasets found';
+        (0, $7soKB$logger).error(message);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+    }
+    const arr = metadata.arrays.find((a)=>a.path === level.path);
+    if (!arr) {
+        const message = `cannot load slice: no array found for path [${level.path}]`;
+        (0, $7soKB$logger).error(message);
+        throw new (0, $8af220877f5aad67$export$e819e674f1e05236)(message);
+    }
+    const { raw: raw } = await $62574ebf548584b6$var$loadZarrArrayFileFromStore(store, arr.path, metadata.zarrVersion, false);
+    const result = await $7soKB$get(raw, $62574ebf548584b6$var$buildQuery(r, axes, level.shape), {
+        opts: {
+            signal: signal ?? null
+        }
+    });
+    if (typeof result === 'number') throw new Error('oh noes, slice came back all weird');
+    return {
+        shape: result.shape,
+        buffer: result
+    };
+}
+
+
+/**
+ * given a image with @param size pixels, break it into tiles, each @param idealTilePx.
+ * for all such tiles which intersect the given bounds, call the visitor
+ * @param idealTilePx the size of a tile, in pixels
+ * @param size the size of the image at this level of detail
+ * @param bounds visit only the tiles that are within the given bounds (in pixels)
+ */ function $4a90fbb98bec80dd$var$visitTilesWithin(idealTilePx, size, bounds, visit) {
+    const withinBoth = (0, $7soKB$Box2D).intersection(bounds, (0, $7soKB$Box2D).create([
+        0,
+        0
+    ], size));
+    if (!withinBoth) return;
+    // convert the image into tile indexes:
+    const boundsInTiles = (0, $7soKB$Box2D).map(withinBoth, (corner)=>(0, $7soKB$Vec2).div(corner, idealTilePx));
+    for(let x = Math.floor(boundsInTiles.minCorner[0]); x < Math.ceil(boundsInTiles.maxCorner[0]); x += 1)for(let y = Math.floor(boundsInTiles.minCorner[1]); y < Math.ceil(boundsInTiles.maxCorner[1]); y += 1){
+        // all tiles visited are always within both the bounds, and the image itself
+        const lo = (0, $7soKB$Vec2).mul([
+            x,
+            y
+        ], idealTilePx);
+        const hi = (0, $7soKB$Vec2).min(size, (0, $7soKB$Vec2).add(lo, idealTilePx));
+        visit((0, $7soKB$Box2D).create(lo, hi));
+    }
+}
+function $4a90fbb98bec80dd$var$getVisibleTilesInLayer(camera, plane, orthoVal, dataset, tileSize, level) {
+    const size = (0, $62574ebf548584b6$export$ba17f86721d4d0ce)(plane, dataset.attrs.multiscales[0].axes, level);
+    const realSize = (0, $62574ebf548584b6$export$c5890dae76bd0ad7)(plane, dataset.attrs.multiscales[0].axes, level);
+    if (!size || !realSize) return [];
+    const scale = (0, $7soKB$Vec2).div(realSize, size);
+    const vxlToReal = (vxl)=>(0, $7soKB$Box2D).scale(vxl, scale);
+    const realToVxl = (real)=>(0, $7soKB$Box2D).scale(real, (0, $7soKB$Vec2).div([
+            1,
+            1
+        ], scale));
+    const visibleTiles = [];
+    $4a90fbb98bec80dd$var$visitTilesWithin([
+        tileSize,
+        tileSize
+    ], size, realToVxl(camera.view), (uv)=>{
+        visibleTiles.push({
+            plane: plane.axes,
+            realBounds: vxlToReal(uv),
+            bounds: uv,
+            orthoVal: orthoVal,
+            level: level
+        });
+    });
+    return visibleTiles;
+}
+function $4a90fbb98bec80dd$export$2957f72eb8eb81d4(camera, plane, planeLocation, metadata, tileSize) {
+    // TODO (someday) open the array, look at its chunks, use that size for the size of the tiles I request!
+    const layer = (0, $62574ebf548584b6$export$8efeb0367ee93033)(metadata, plane, camera.view, camera.screenSize);
+    // figure out the index of the slice
+    const sliceIndex = (0, $62574ebf548584b6$export$81eb4b4b765d519)(layer, metadata.attrs.multiscales[0].axes, planeLocation, plane.ortho);
+    return $4a90fbb98bec80dd$var$getVisibleTilesInLayer(camera, plane, sliceIndex, metadata, tileSize, layer);
+}
+const $4a90fbb98bec80dd$export$e83f4de492e8b929 = (metadata, r, level, signal)=>{
+    return (0, $62574ebf548584b6$export$831e2eeffaa681)(metadata, r, level, signal).then((result)=>{
+        const { shape: shape, buffer: buffer } = result;
+        return {
+            shape: shape,
+            data: new Float32Array(buffer.data)
+        };
+    });
+};
+
+
+// render a slice of an ome-zarr file as a 2D image
+// note that the ome-zarr data must have exactly 3 channels
+// the channels may be mapped to color-channels (RGB) with a basic 2-post gamut control
+const $3e6603f747b5a8a4$var$vert = /*glsl*/ `
+precision highp float;
+attribute vec2 pos;
+    
+uniform vec4 view;
+uniform vec4 tile;
+uniform float depth;
+varying vec2 texCoord;
+uniform float rot;
+
+void main(){
+    vec2 tileSize = tile.zw-tile.xy;
+    texCoord = pos;
+    vec2 obj = (pos.xy*tileSize+tile.xy);
+
+    vec2 p = (obj-view.xy)/(view.zw-view.xy);
+    // now, to clip space
+    p = (p*2.0)-1.0;
+    gl_Position = vec4(p.x,p.y,depth,1.0);
+}
+`;
+function $3e6603f747b5a8a4$export$36d69f6355ac98ab(regl) {
+    const cmd = regl({
+        vert: $3e6603f747b5a8a4$var$vert,
+        frag: `
+    precision highp float;
+    uniform sampler2D R;
+    uniform sampler2D G;
+    uniform sampler2D B; // for reasons which are pretty annoying
+    // its more direct to do 3 separate channels...
+    uniform vec2 Rgamut;
+    uniform vec2 Ggamut;
+    uniform vec2 Bgamut;
+    
+    varying vec2 texCoord;
+    void main(){
+            vec3 mins = vec3(Rgamut.x,Ggamut.x,Bgamut.x);
+            vec3 maxs = vec3(Rgamut.y,Ggamut.y,Bgamut.y);
+            vec3 span = maxs-mins;
+            vec3 color = (vec3(
+                texture2D(R, texCoord).r,
+                texture2D(G, texCoord).r,
+                texture2D(B, texCoord).r
+            )-mins) /span;
+           
+            gl_FragColor = vec4(color, 1.0);
+        }`,
+        framebuffer: regl.prop('target'),
+        attributes: {
+            pos: [
+                0,
+                0,
+                1,
+                0,
+                1,
+                1,
+                0,
+                1
+            ]
+        },
+        uniforms: {
+            tile: regl.prop('tile'),
+            view: regl.prop('view'),
+            depth: regl.prop('depth'),
+            R: regl.prop('R'),
+            G: regl.prop('G'),
+            B: regl.prop('B'),
+            Rgamut: regl.prop('Rgamut'),
+            Ggamut: regl.prop('Ggamut'),
+            Bgamut: regl.prop('Bgamut')
+        },
+        depth: {
+            enable: true
+        },
+        count: 4,
+        primitive: 'triangle fan'
+    });
+    return (p)=>cmd(p);
+}
+function $3e6603f747b5a8a4$export$ecfa859e3c9f4021(regl, numChannels) {
+    const reglChannelUniforms = [];
+    const fragmentChannelUniformDefs = [];
+    const colorMerges = [];
+    for(let i = 0; i < numChannels; i++){
+        reglChannelUniforms.push({
+            [`gamut${i}`]: (_context, props)=>props.channels[i].gamut,
+            [`color${i}`]: (_context, props)=>props.channels[i].rgb,
+            [`tex${i}`]: (_context, props)=>props.channels[i].tex
+        });
+        fragmentChannelUniformDefs.push(`uniform vec2 gamut${i};`);
+        fragmentChannelUniformDefs.push(`uniform vec3 color${i};`);
+        fragmentChannelUniformDefs.push(`uniform sampler2D tex${i};`);
+        colorMerges.push(`
+            float ch${i}Val = texture2D(tex${i}, texCoord).r;
+            ch${i}Val = (ch${i}Val - gamut${i}.x) / (gamut${i}.y - gamut${i}.x);
+            color += (color${i} * ch${i}Val);
+        `);
+    }
+    const staticReglUniforms = {
+        tile: regl.prop('tile'),
+        view: regl.prop('view'),
+        depth: regl.prop('depth')
+    };
+    const uniforms = reglChannelUniforms.reduce((acc, curr)=>{
+        for(const key in curr)acc[key] = curr[key];
+        return acc;
+    }, staticReglUniforms);
+    const frag = `
+        precision highp float;
+        ${fragmentChannelUniformDefs.join('\n')}
+        varying vec2 texCoord;
+
+        void main() {
+            vec3 color = vec3(0.0, 0.0, 0.0);
+            ${colorMerges.join('\n')}
+            color = clamp(color, 0.0, 1.0);
+            gl_FragColor = vec4(color, 1.0);
+        }`;
+    // biome-ignore lint/suspicious/noExplicitAny: type of uniforms cannot be given explicitly due to dynamic nature of uniforms in these shaders
+    const cmd = regl({
+        vert: $3e6603f747b5a8a4$var$vert,
+        frag: frag,
+        framebuffer: regl.prop('target'),
+        attributes: {
+            pos: [
+                0,
+                0,
+                1,
+                0,
+                1,
+                1,
+                0,
+                1
+            ]
+        },
+        uniforms: uniforms,
+        depth: {
+            enable: true
+        },
+        count: 4,
+        primitive: 'triangle fan'
+    });
+    return (p)=>cmd(p);
+}
+
+
+function $6f9a458a1fcc6b82$var$toZarrRequest(tile, channel) {
+    const { plane: plane, orthoVal: orthoVal, bounds: bounds } = tile;
+    const { minCorner: min, maxCorner: max } = bounds;
+    const u = {
+        min: min[0],
+        max: max[0]
+    };
+    const v = {
+        min: min[1],
+        max: max[1]
+    };
+    switch(plane){
+        case 'xy':
+            return {
+                x: u,
+                y: v,
+                t: 0,
+                c: channel,
+                z: orthoVal
+            };
+        case 'xz':
+            return {
+                x: u,
+                z: v,
+                t: 0,
+                c: channel,
+                y: orthoVal
+            };
+        case 'yz':
+            return {
+                y: u,
+                z: v,
+                t: 0,
+                c: channel,
+                x: orthoVal
+            };
+    }
+}
+function $6f9a458a1fcc6b82$var$isPrepared(cacheData) {
+    if (!cacheData) return false;
+    const keys = Object.keys(cacheData);
+    if (keys.length < 1) return false;
+    return keys.every((key)=>cacheData[key]?.type === 'texture');
+}
+const $6f9a458a1fcc6b82$var$DEFAULT_NUM_CHANNELS = 3;
+function $6f9a458a1fcc6b82$export$c97bf2bbe9bf6d5e(regl, decoder, options) {
+    const numChannels = options?.numChannels ?? $6f9a458a1fcc6b82$var$DEFAULT_NUM_CHANNELS;
+    function sliceAsTexture(slice) {
+        const { data: data, shape: shape } = slice;
+        return {
+            bytes: data.byteLength,
+            texture: regl.texture({
+                data: data,
+                width: shape[1],
+                height: shape[0],
+                format: 'luminance'
+            }),
+            type: 'texture'
+        };
+    }
+    const cmd = (0, $3e6603f747b5a8a4$export$ecfa859e3c9f4021)(regl, numChannels);
+    return {
+        cacheKey: (item, requestKey, dataset, settings)=>{
+            const channelKeys = Object.keys(settings.channels);
+            if (!channelKeys.includes(requestKey)) {
+                const message = `cannot retrieve cache key: unrecognized requestKey [${requestKey}]`;
+                (0, $7soKB$logger).error(message);
+                throw new Error(message);
+            }
+            return `${dataset.url}_${JSON.stringify(item)}_ch=${requestKey}`;
+        },
+        destroy: ()=>{},
+        getVisibleItems: (dataset, settings)=>{
+            const { camera: camera, plane: plane, planeLocation: planeLocation, tileSize: tileSize } = settings;
+            return (0, $4a90fbb98bec80dd$export$2957f72eb8eb81d4)(camera, plane, planeLocation, dataset, tileSize);
+        },
+        fetchItemContent: (item, dataset, settings)=>{
+            const contents = {};
+            for(const key in settings.channels)contents[key] = (signal)=>decoder(dataset, $6f9a458a1fcc6b82$var$toZarrRequest(item, settings.channels[key].index), item.level, signal).then(sliceAsTexture);
+            return contents;
+        },
+        isPrepared: $6f9a458a1fcc6b82$var$isPrepared,
+        renderItem: (target, item, dataset, settings, gpuData)=>{
+            const channels = Object.keys(gpuData).map((key)=>({
+                    tex: gpuData[key].texture,
+                    gamut: (0, $7soKB$intervalToVec2)(settings.channels[key].gamut),
+                    rgb: settings.channels[key].rgb
+                }));
+            const layers = dataset.getNumLayers();
+            // per the spec, the highest resolution layer should be first
+            // we want that layer most in front, so:
+            const depth = item.level.datasetIndex / layers;
+            const { camera: camera } = settings;
+            cmd({
+                channels: channels,
+                target: target,
+                depth: depth,
+                tile: (0, $7soKB$Box2D).toFlatArray(item.realBounds),
+                view: (0, $7soKB$Box2D).toFlatArray(camera.view)
+            });
+        }
+    };
+}
+function $6f9a458a1fcc6b82$export$79b7536e23e20727(regl, decoder, options) {
+    return (0, $7soKB$buildAsyncRenderer)($6f9a458a1fcc6b82$export$c97bf2bbe9bf6d5e(regl, decoder, options), options?.queueOptions);
+}
+
+
+
+
+
+
+
+
+
+
+function $e7ae61881db7ab65$var$isSliceRequest(payload) {
+    return typeof payload === 'object' && payload !== null && 'type' in payload && payload.type === 'ZarrSliceRequest';
+}
+function $e7ae61881db7ab65$var$isCancellationRequest(payload) {
+    return typeof payload === 'object' && payload !== null && 'type' in payload && payload.type === 'cancel';
+}
+function $e7ae61881db7ab65$export$79bc3a420a6742ac(ctx) {
+    const cancelers = {};
+    ctx.onmessage = (msg)=>{
+        const { data: data } = msg;
+        try {
+            if ($e7ae61881db7ab65$var$isSliceRequest(data)) {
+                const { metadata: dehydratedMetadata, req: req, level: level, id: id } = data;
+                const abort = new AbortController();
+                cancelers[id] = abort;
+                (0, $0ff6a7cfdd9baaf1$export$c7c266bed5c41e68).rehydrate(dehydratedMetadata).then((metadata)=>{
+                    (0, $62574ebf548584b6$export$831e2eeffaa681)(metadata, req, level, abort.signal).then((result)=>{
+                        const { shape: shape, buffer: buffer } = result;
+                        const data = new Float32Array(buffer.data);
+                        ctx.postMessage({
+                            type: 'slice',
+                            id: id,
+                            shape: shape,
+                            data: data
+                        }, {
+                            transfer: [
+                                data.buffer
+                            ]
+                        });
+                    }).catch((err)=>{
+                        if (!(err === 'cancelled' || typeof err === 'object' && ('name' in err && err.name === 'AbortError' || 'code' in err && err.code === 20))) (0, $7soKB$logger).error('error in slice fetch worker: ', err);
+                         // else ignore it
+                    });
+                });
+            } else if ($e7ae61881db7ab65$var$isCancellationRequest(data)) {
+                const { id: id } = data;
+                cancelers[id]?.abort('cancelled');
+            } else (0, $7soKB$logger).error('web-worker slice-fetcher recieved incomprehensible message: ', msg);
+        } catch (err) {
+            (0, $7soKB$logger).error('OME-Zarr fetch onmessage error', err);
+        }
+    };
+}
+
+
+
+
+export {$6f9a458a1fcc6b82$export$c97bf2bbe9bf6d5e as buildOmeZarrSliceRenderer, $6f9a458a1fcc6b82$export$79b7536e23e20727 as buildAsyncOmezarrRenderer, $8af220877f5aad67$export$96bea966bad52d02 as VisZarrError, $8af220877f5aad67$export$e819e674f1e05236 as VisZarrDataError, $8af220877f5aad67$export$d7f857358a0dbda6 as VisZarrIndexError, $4a90fbb98bec80dd$export$e83f4de492e8b929 as defaultDecoder, $4a90fbb98bec80dd$export$2957f72eb8eb81d4 as getVisibleTiles, $3e6603f747b5a8a4$export$ecfa859e3c9f4021 as buildTileRenderer, $3e6603f747b5a8a4$export$36d69f6355ac98ab as buildRGBTileRenderer, $0ff6a7cfdd9baaf1$export$9989519d74cf4fd0 as OmeZarrAxisSchema, $0ff6a7cfdd9baaf1$export$13526d3947c5c7c2 as OmeZarrCoordinateTranslationSchema, $0ff6a7cfdd9baaf1$export$f0f448c9214bb1a1 as OmeZarrCoordinateScaleSchema, $0ff6a7cfdd9baaf1$export$2e1c7be8e43a67e3 as OmeZarrCoordinateTransformSchema, $0ff6a7cfdd9baaf1$export$a535e1d8aa90b3c9 as OmeZarrDatasetSchema, $0ff6a7cfdd9baaf1$export$d7d6a65692bb1dc0 as OmeZarrMultiscaleSchema, $0ff6a7cfdd9baaf1$export$90729eda236ba57 as OmeZarrOmeroChannelWindowSchema, $0ff6a7cfdd9baaf1$export$bb4e42bb52e6d21d as OmeZarrOmeroChannelSchema, $0ff6a7cfdd9baaf1$export$51e803dddccc5479 as OmeZarrOmeroSchema, $0ff6a7cfdd9baaf1$export$a3b48a0a4f3d252 as OmeZarrAttrsSchema, $0ff6a7cfdd9baaf1$export$c7c266bed5c41e68 as OmeZarrMetadata, $62574ebf548584b6$export$7999b0bb51b3dcb8 as loadMetadata, $62574ebf548584b6$export$7f36aeab32ab33f7 as loadZarrArrayFile, $62574ebf548584b6$export$78b8536ed7d8a60d as loadZarrAttrsFile, $62574ebf548584b6$export$8efeb0367ee93033 as pickBestScale, $62574ebf548584b6$export$831e2eeffaa681 as loadSlice, $62574ebf548584b6$export$c5890dae76bd0ad7 as sizeInUnits, $62574ebf548584b6$export$fcb1a44ca126ee5c as sizeInVoxels, $62574ebf548584b6$export$ca023b1dd6252668 as nextSliceStep, $62574ebf548584b6$export$ba17f86721d4d0ce as planeSizeInVoxels, $e7ae61881db7ab65$export$79bc3a420a6742ac as makeOmeZarrSliceLoaderWorker};
+//# sourceMappingURL=module.js.map