@alleninstitute/vis-omezarr 0.0.17

package/dist/main.js

@@ -0,0 +1,1365 @@
+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, PriorityCache as $7soKB$PriorityCache, WorkerPool as $7soKB$WorkerPool, HEARTBEAT_RATE_MS as $7soKB$HEARTBEAT_RATE_MS} 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 $7soKB$zod, {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$export$ab574f5010f64a15(store, path, version, loadV2Attrs);
+    return result.metadata;
+}
+async function $62574ebf548584b6$export$ab574f5010f64a15(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$export$ab574f5010f64a15(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]
+    ];
+}
+function $62574ebf548584b6$export$d7b58f10109feb02(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$export$ab574f5010f64a15(store, arr.path, metadata.zarrVersion, false);
+    const result = await $7soKB$get(raw, $62574ebf548584b6$export$d7b58f10109feb02(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
+/* ================ TILE RENDERING VERTEX SHADER ================ */ const $3e6603f747b5a8a4$var$tileVert = /*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);
+}
+`;
+/* -------------------------------------------------------------- */ /* ============= RGB TILE RENDERING FRAGMENT SHADER ============= */ const $3e6603f747b5a8a4$var$rgbFrag = /*glsl*/ `
+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);
+}
+`;
+function $3e6603f747b5a8a4$export$e1c4d8365a017448(regl) {
+    const cmd = regl({
+        vert: $3e6603f747b5a8a4$var$tileVert,
+        frag: $3e6603f747b5a8a4$var$rgbFrag,
+        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$640f994018c81008(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$tileVert,
+        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$640f994018c81008)(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);
+        }
+    };
+}
+
+
+
+
+
+
+
+
+
+const $5b408c6c3c009876$export$c73be2def9fc3425 = 'fetch';
+const $5b408c6c3c009876$export$d7c94d771e5d9aa7 = 'fetch-response';
+const $5b408c6c3c009876$export$75e5bf1b92806f35 = 'cancel';
+const $5b408c6c3c009876$var$FetchMessagePayloadSchema = (0, $7soKB$zod).object({
+    rootUrl: (0, $7soKB$zod).string().nonempty(),
+    path: (0, $7soKB$zod).string().nonempty().startsWith('/'),
+    range: (0, $7soKB$zod).union([
+        (0, $7soKB$zod).object({
+            offset: (0, $7soKB$zod).number(),
+            length: (0, $7soKB$zod).number()
+        }),
+        (0, $7soKB$zod).object({
+            suffixLength: (0, $7soKB$zod).number()
+        })
+    ]).optional(),
+    options: (0, $7soKB$zod).unknown().optional()
+});
+const $5b408c6c3c009876$var$FetchMessageSchema = (0, $7soKB$zod).object({
+    type: (0, $7soKB$zod).literal($5b408c6c3c009876$export$c73be2def9fc3425),
+    id: (0, $7soKB$zod).string().nonempty(),
+    payload: $5b408c6c3c009876$var$FetchMessagePayloadSchema
+});
+const $5b408c6c3c009876$var$FetchResponseMessageSchema = (0, $7soKB$zod).object({
+    type: (0, $7soKB$zod).literal($5b408c6c3c009876$export$d7c94d771e5d9aa7),
+    id: (0, $7soKB$zod).string().nonempty(),
+    payload: (0, $7soKB$zod).unknown().optional()
+});
+const $5b408c6c3c009876$var$CancelMessageSchema = (0, $7soKB$zod).object({
+    type: (0, $7soKB$zod).literal($5b408c6c3c009876$export$75e5bf1b92806f35),
+    id: (0, $7soKB$zod).string().nonempty()
+});
+function $5b408c6c3c009876$export$ced8a9318e8c4d3d(val) {
+    return $5b408c6c3c009876$var$FetchMessageSchema.safeParse(val).success;
+}
+function $5b408c6c3c009876$export$87cac8e8f93fed1d(val) {
+    return $5b408c6c3c009876$var$FetchResponseMessageSchema.safeParse(val).success;
+}
+function $5b408c6c3c009876$export$a77d75797e75745f(val) {
+    return $5b408c6c3c009876$var$CancelMessageSchema.safeParse(val).success;
+}
+function $5b408c6c3c009876$export$2b3d06107d1323d4(err) {
+    return err === 'cancelled' || typeof err === 'object' && err !== null && ('name' in err && err.name === 'AbortError' || 'code' in err && err.code === 20);
+}
+
+
+const $81959a80f9a6789a$var$DEFAULT_NUM_WORKERS = 6;
+const $81959a80f9a6789a$var$DEFAULT_MAX_DATA_CACHE_BYTES = 262144; // 256 MB -- aribtrarily chosen at this point
+// @TODO implement a much more context-aware cache size limiting mechanism
+const $81959a80f9a6789a$var$getDataCacheSizeLimit = ()=>{
+    return $81959a80f9a6789a$var$DEFAULT_MAX_DATA_CACHE_BYTES;
+};
+const $81959a80f9a6789a$export$d09252bd498a9707 = (key, range)=>{
+    const keyStr = JSON.stringify(key);
+    const rangeStr = range ? JSON.stringify(range) : 'no-range';
+    return `${keyStr} ${rangeStr}`;
+};
+class $81959a80f9a6789a$var$CacheableByteArray {
+    #arr;
+    constructor(arr){
+        this.#arr = arr;
+    }
+    destroy() {}
+    sizeInBytes() {
+        return this.#arr.byteLength;
+    }
+    get array() {
+        return this.#arr;
+    }
+}
+const $81959a80f9a6789a$var$copyToTransferableHeaders = (headers)=>{
+    if (Array.isArray(headers)) {
+        const result = {};
+        headers.forEach(([key, val])=>{
+            // TODO is key, val the correct order here?
+            result[key] = val;
+        });
+        return result;
+    }
+    if (headers instanceof Headers) {
+        const result = {};
+        headers.forEach((val, key)=>{
+            result[key] = val;
+        });
+        return result;
+    }
+    return headers;
+};
+const $81959a80f9a6789a$var$copyToTransferableRequestInit = (req)=>{
+    if (req === undefined) return {};
+    const updReq = {
+        ...req
+    };
+    delete updReq.signal;
+    delete updReq.window;
+    return {
+        ...updReq,
+        body: req.body?.toString(),
+        headers: $81959a80f9a6789a$var$copyToTransferableHeaders(req.headers)
+    };
+};
+class $81959a80f9a6789a$export$927188fe483fb171 extends $7soKB$FetchStore {
+    /**
+     * Maintains a pool of available worker threads.
+     *
+     * TODO: Enable end-to-end Message-based type constraints for these that
+     * enable us to restrict what types of messages can be sent to workers
+     * for a given store instance.
+     */ // biome-ignore lint/suspicious/noExplicitAny: the type system for these parameters is a future feature
+    #workerPool;
+    /**
+     * Stores the current set of cached data that has been successfully
+     * fetched. This data is stored in raw byte array form so that it
+     * integrates properly with the Zarrita framework.
+     */ #dataCache;
+    /**
+     * Maps cache keys to numeric times; the higher the time, the higher the priority.
+     *
+     * This effectively means that more frequently-requested items will be kept longer.
+     */ #priorityByTimestamp;
+    /**
+     * Stores in-progress requests that have not yet resolved.
+     */ #pendingRequests;
+    /**
+     * Stores one instance of a cache key for each time that cache key was requested,
+     * removing them all once that particular request is fulfilled. This allows us to
+     * keep track of whether or not it is safe to abort a pending request: as long as
+     * there are at least 2 instances of the same cache key in this array, then that
+     * means multiple requestors are waiting on a particular piece of data, and it is
+     * not safe to abort that request.
+     */ #pendingRequestKeyCounts;
+    /**
+     * A callback form of the `score` function.
+     */ #scoreFn;
+    // biome-ignore lint/suspicious/noExplicitAny: the type system for these parameters is a future feature
+    constructor(url, handler, options){
+        super(url, options?.fetchStoreOptions);
+        this.#scoreFn = (h)=>this.score(h);
+        this.#dataCache = new (0, $7soKB$PriorityCache)(new Map(), this.#scoreFn, options?.maxBytes ?? $81959a80f9a6789a$var$getDataCacheSizeLimit());
+        this.#priorityByTimestamp = new Map();
+        this.#workerPool = handler;
+        this.#pendingRequests = new Map();
+        this.#pendingRequestKeyCounts = new Map();
+    }
+    /**
+     * Warning - nothing in this class should be considered useable after
+     * calling this method - any/all methods called should be expected to be
+     * completely unreliable. dont call me unless you're about to dispose of all references to this object
+     */ destroy() {
+        // release all the web-workers!
+        this.#workerPool.destroy();
+        // todo: reject all promises
+        this.#pendingRequests.forEach((p)=>{
+            p.reject('cancelled');
+        });
+    }
+    score(key) {
+        return this.#priorityByTimestamp.get(key) ?? 0;
+    }
+    #fromCache(cacheKey) {
+        const cached = this.#dataCache.get(cacheKey);
+        if (cached === undefined) return undefined;
+        this.#priorityByTimestamp.set(cacheKey, Date.now());
+        return cached.array;
+    }
+    #incrementKeyCount(cacheKey) {
+        const count = this.#pendingRequestKeyCounts.get(cacheKey);
+        const newCount = count !== undefined ? count + 1 : 1;
+        this.#pendingRequestKeyCounts.set(cacheKey, newCount);
+        return newCount;
+    }
+    #decrementKeyCount(cacheKey) {
+        const count = this.#pendingRequestKeyCounts.get(cacheKey);
+        if (count === undefined) {
+            (0, $7soKB$logger).warn('attempted to decrement a non-existent request key');
+            return 0;
+        }
+        if (count <= 1) {
+            this.#pendingRequestKeyCounts.delete(cacheKey);
+            return 0;
+        }
+        const newCount = count - 1;
+        this.#pendingRequestKeyCounts.set(cacheKey, newCount);
+        return newCount;
+    }
+    async #doFetch(key, range, options, abort) {
+        const cacheKey = $81959a80f9a6789a$export$d09252bd498a9707(key, range);
+        this.#priorityByTimestamp.set(cacheKey, Date.now());
+        this.#dataCache.reprioritize(this.#scoreFn);
+        this.#incrementKeyCount(cacheKey);
+        const pending = this.#pendingRequests.get(cacheKey);
+        if (pending !== undefined) return pending.promise;
+        const { promise: promise, resolve: resolve, reject: reject } = Promise.withResolvers();
+        this.#pendingRequests.set(cacheKey, {
+            promise: promise,
+            resolve: resolve,
+            reject: reject
+        });
+        const chain = new AbortController();
+        if (abort) abort.addEventListener('abort', ()=>{
+            const count = this.#decrementKeyCount(cacheKey);
+            if (count === 0) {
+                this.#priorityByTimestamp.set(cacheKey, 0);
+                this.#dataCache.reprioritize(this.#scoreFn);
+                chain.abort();
+            }
+        });
+        const request = this.#workerPool.submitRequest({
+            type: (0, $5b408c6c3c009876$export$c73be2def9fc3425),
+            payload: {
+                rootUrl: this.url,
+                path: key,
+                range: range,
+                options: options
+            }
+        }, (0, $5b408c6c3c009876$export$87cac8e8f93fed1d), [], chain.signal);
+        request.then((response)=>{
+            const payload = response.payload;
+            if (payload === undefined) {
+                resolve(undefined);
+                return;
+            }
+            const arr = new Uint8Array(payload);
+            this.#dataCache.put(cacheKey, new $81959a80f9a6789a$var$CacheableByteArray(arr));
+            resolve(arr);
+        }).catch((e)=>{
+            reject(e);
+        }).finally(()=>{
+            this.#pendingRequests.delete(cacheKey);
+            this.#pendingRequestKeyCounts.delete(cacheKey);
+        });
+        return promise;
+    }
+    async get(key, options) {
+        const cacheKey = $81959a80f9a6789a$export$d09252bd498a9707(key);
+        const cached = this.#fromCache(cacheKey);
+        if (cached !== undefined) return cached;
+        const workerOptions = $81959a80f9a6789a$var$copyToTransferableRequestInit(options);
+        const abort = options?.signal ?? undefined;
+        return this.#doFetch(key, undefined, workerOptions, abort);
+    }
+    async getRange(key, range, options) {
+        const cacheKey = $81959a80f9a6789a$export$d09252bd498a9707(key, range);
+        const cached = this.#fromCache(cacheKey);
+        if (cached !== undefined) return cached;
+        const workerOptions = $81959a80f9a6789a$var$copyToTransferableRequestInit(options);
+        const abort = options?.signal ?? undefined;
+        return this.#doFetch(key, range, workerOptions, abort);
+    }
+}
+class $81959a80f9a6789a$export$80a50be84de8c993 extends $81959a80f9a6789a$export$927188fe483fb171 {
+    constructor(url, workerModule, options){
+        super(url, new (0, $7soKB$WorkerPool)(options?.numWorkers ?? $81959a80f9a6789a$var$DEFAULT_NUM_WORKERS, workerModule), options);
+    }
+}
+
+
+function $845a7aab26aa4fe6$export$fc561c682218655c(url, workerModule, options) {
+    const store = new (0, $81959a80f9a6789a$export$80a50be84de8c993)(url, workerModule, options);
+    const getSlice = async (metadata, req, level, signal)=>{
+        if (metadata.url !== url) throw new Error('trying to use a decoder from a different store - we cant do that yet, although we could build a map of url->stores here if we wanted later - TODO');
+        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 (0, $62574ebf548584b6$export$ab574f5010f64a15)(store, arr.path, metadata.zarrVersion, false);
+        const result = await $7soKB$get(raw, (0, $62574ebf548584b6$export$d7b58f10109feb02)(req, axes, level.shape), {
+            opts: {
+                signal: signal ?? null
+            }
+        });
+        if (typeof result === 'number') throw new Error('oh noes, slice came back all weird');
+        const { shape: shape, data: data } = result;
+        if (typeof data !== 'object' || !('buffer' in data)) throw new Error('slice was malformed, array-buffer response required');
+        // biome-ignore lint/suspicious/noExplicitAny: <hard to prove - but the typeof check above is sufficient for this to be safe>
+        return {
+            shape: shape,
+            data: new Float32Array(data)
+        };
+    };
+    return {
+        decoder: getSlice,
+        destroy: ()=>{
+            store.destroy();
+        }
+    };
+}
+
+
+// a web-worker which fetches slices of data, decodes them, and returns the result as a flat float32 array, using transferables
+
+
+
+const $b2fe35b4140f0787$var$NUM_RETRIES = 2;
+const $b2fe35b4140f0787$var$RETRY_DELAY_MS = 500;
+const $b2fe35b4140f0787$var$fetchFile = async (rootUrl, path, options, abortController)=>{
+    const store = new (0, $7soKB$FetchStore)(rootUrl);
+    return store.get(path, {
+        ...options || {},
+        signal: abortController?.signal ?? null
+    });
+};
+const $b2fe35b4140f0787$var$fetchSlice = async (rootUrl, path, range, options, abortController)=>{
+    const store = new (0, $7soKB$FetchStore)(rootUrl);
+    const wait = async (ms)=>new Promise((resolve)=>{
+            setTimeout(resolve, ms);
+        });
+    for(let i = 0; i < $b2fe35b4140f0787$var$NUM_RETRIES; i++)try {
+        return await store.getRange(path, range, {
+            ...options || {},
+            signal: abortController?.signal ?? null
+        });
+    } catch (e) {
+        (0, $7soKB$logger).error('getRange request failed:', e);
+        const hasRetries = i < $b2fe35b4140f0787$var$NUM_RETRIES - 1;
+        const message = `getRange request ${i < $b2fe35b4140f0787$var$NUM_RETRIES - 1 ? `will retry in ${$b2fe35b4140f0787$var$RETRY_DELAY_MS}ms` : 'has no retries left'}`;
+        (0, $7soKB$logger).warn(message);
+        if (hasRetries) await wait($b2fe35b4140f0787$var$RETRY_DELAY_MS);
+    }
+    return undefined;
+};
+const $b2fe35b4140f0787$var$handleFetch = (message, abortControllers)=>{
+    const { id: id, payload: payload } = message;
+    const { rootUrl: rootUrl, path: path, range: range, options: options } = payload;
+    if (id in abortControllers) {
+        (0, $7soKB$logger).error('cannot send message: request ID already in use');
+        return;
+    }
+    const abort = new AbortController();
+    abortControllers[id] = abort;
+    const fetchFn = range !== undefined ? ()=>$b2fe35b4140f0787$var$fetchSlice(rootUrl, path, range, options, abort) : ()=>$b2fe35b4140f0787$var$fetchFile(rootUrl, path, options, abort);
+    fetchFn().then((result)=>{
+        const buffer = result?.buffer;
+        const options = buffer !== undefined ? {
+            transfer: [
+                buffer
+            ]
+        } : {};
+        self.postMessage({
+            type: (0, $5b408c6c3c009876$export$d7c94d771e5d9aa7),
+            id: id,
+            payload: result?.buffer
+        }, {
+            ...options
+        });
+    }).catch((e)=>{
+        if (!(0, $5b408c6c3c009876$export$2b3d06107d1323d4)(e)) (0, $7soKB$logger).error('error in slice fetch worker: ', e);
+    // can ignore if it is a cancellation error
+    });
+};
+const $b2fe35b4140f0787$var$handleCancel = (message, abortControllers)=>{
+    const { id: id } = message;
+    const abortController = abortControllers[id];
+    if (!abortController) (0, $7soKB$logger).warn('attempted to cancel a non-existent request');
+    else abortController.abort('cancelled');
+};
+const $b2fe35b4140f0787$var$startHeartbeat = ()=>setInterval(()=>{
+        self.postMessage({
+            type: 'heartbeat'
+        });
+    }, (0, $7soKB$HEARTBEAT_RATE_MS));
+const $b2fe35b4140f0787$var$setupOnMessage = ()=>{
+    const abortControllers = {};
+    const onmessage = async (e)=>{
+        const { data: message } = e;
+        if ((0, $5b408c6c3c009876$export$ced8a9318e8c4d3d)(message)) $b2fe35b4140f0787$var$handleFetch(message, abortControllers);
+        else if ((0, $5b408c6c3c009876$export$a77d75797e75745f)(message)) $b2fe35b4140f0787$var$handleCancel(message, abortControllers);
+    };
+    return onmessage;
+};
+const $b2fe35b4140f0787$export$4908e147e219e01a = (ctx)=>{
+    ctx.onmessage = $b2fe35b4140f0787$var$setupOnMessage();
+    return {
+        startHeartbeat: $b2fe35b4140f0787$var$startHeartbeat
+    };
+};
+
+
+
+
+
+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$640f994018c81008 as buildTileRenderCommand, $3e6603f747b5a8a4$export$e1c4d8365a017448 as buildRGBTileRenderCommand, $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, $845a7aab26aa4fe6$export$fc561c682218655c as decoderFactory, $b2fe35b4140f0787$export$4908e147e219e01a as setupFetchDataWorker, $5b408c6c3c009876$export$ced8a9318e8c4d3d as isFetchMessage, $5b408c6c3c009876$export$87cac8e8f93fed1d as isFetchResponseMessage, $5b408c6c3c009876$export$a77d75797e75745f as isCancelMessage, $5b408c6c3c009876$export$2b3d06107d1323d4 as isCancellationError};
+//# sourceMappingURL=main.js.map