@jax-data-science/sci-image-visualizer 0.10.0 → 0.12.0

package/esm2022/lib/region-import/ome-zarr-labels.mjs

@@ -0,0 +1,253 @@
+/**
+ * A label image of an OME-Zarr store (`labels/<name>/`, NGFF 0.4 on zarr v2 or 0.5 on zarr v3),
+ * read in the browser from the store's files (a folder chosen, or a zip's members): its full
+ * resolution level, sliced along z, with the classes its `image-label` metadata names and colours.
+ *
+ * Chunks are decoded when a slice that needs them is read, so a store is never decoded whole.
+ * Only what label images use: C-order chunks of integer (or integer-valued float) samples, through
+ * the codecs {@link decodeChunk} reads, a missing chunk being the fill value. Sharded or transposed
+ * arrays, F-order and filters throw rather than be read wrongly. Pure: usable from workers.
+ */
+import { labelClasses } from './label-classes';
+import { decodeChunk } from './zarr-codecs';
+/** Whether `files` hold a zarr store (any zarr metadata among them). */
+export function hasZarrMetadata(files) {
+    return files.some((f) => /(^|\/)(\.zattrs|\.zarray|\.zgroup|zarr\.json)$/.test(norm(f.name)));
+}
+/**
+ * The first label image of the zarr store among `files` (the order `labels/`'s listing gives,
+ * else the first found), or null when the store has none.
+ */
+export async function readOmeZarrLabels(files, inflate) {
+    const byPath = new Map(files.map((f) => [norm(f.name), f]));
+    const groups = new Map();
+    for (const [path, file] of byPath) {
+        const m = /^(.*?)\/?(\.zattrs|zarr\.json)$/.exec(path);
+        if (!m)
+            continue;
+        const doc = JSON.parse(await file.text());
+        const attrs = (m[2] === 'zarr.json' ? doc['attributes'] : doc) ?? {};
+        groups.set(m[1], (attrs['ome'] ?? attrs));
+    }
+    const listed = [];
+    for (const [dir, ome] of groups) {
+        for (const name of ome['labels'] ?? [])
+            listed.push(join(dir, name));
+    }
+    const isLabel = (dir) => {
+        const ome = groups.get(dir);
+        return !!ome?.['multiscales'] && (!!ome['image-label'] || /(^|\/)labels\/[^/]+$/.test(dir));
+    };
+    const dir = [...listed, ...groups.keys()].find(isLabel);
+    if (dir === undefined)
+        return null;
+    const ome = groups.get(dir);
+    const ms = ome['multiscales'][0];
+    const dataset = ms.datasets[0];
+    const array = await readArrayMeta(byPath, join(dir, dataset.path));
+    const axes = (ms.axes ?? ['z', 'y', 'x'].slice(3 - array.shape.length)).map((a) => typeof a === 'string' ? { name: a } : a);
+    if (axes.length !== array.shape.length)
+        throw new Error(`OME-Zarr ${dir}: ${axes.length} axes for a ${array.shape.length}-D array`);
+    const at = (n) => axes.findIndex((a) => a.name.toLowerCase() === n);
+    const ix = at('x');
+    const iy = at('y');
+    const iz = at('z');
+    if (ix < 0 || iy < 0)
+        throw new Error(`OME-Zarr ${dir}: no x and y axes`);
+    const scale = dataset.coordinateTransformations?.find((t) => t.type === 'scale')?.scale;
+    const um = (i) => (i < 0 ? 1 : (scale?.[i] ?? 1) * unitToMicrons(axes[i].unit));
+    const stack = labelStack(byPath, join(dir, dataset.path), array, { ix, iy, iz }, inflate);
+    stack.spacing = [um(ix), um(iy), iz < 0 ? 1 : um(iz)];
+    const name = ms.name ?? dir.split('/').pop() ?? 'labels';
+    return { name, stack, classes: imageLabelClasses(ome['image-label']) };
+}
+async function readArrayMeta(byPath, path) {
+    const v2 = byPath.get(join(path, '.zarray'));
+    if (v2) {
+        const m = JSON.parse(await v2.text());
+        if (m.order && m.order !== 'C')
+            throw new Error(`zarr ${path}: ${m.order}-order chunks are not supported`);
+        if (m.filters?.length)
+            throw new Error(`zarr ${path}: filters are not supported`);
+        const sep = m.dimension_separator ?? '.';
+        return {
+            shape: m.shape,
+            chunks: m.chunks,
+            dtype: v2Dtype(m.dtype, path),
+            codecs: m.compressor ? [m.compressor] : [],
+            fill: Number(m.fill_value ?? 0) || 0,
+            key: (index) => index.join(sep),
+        };
+    }
+    const v3 = byPath.get(join(path, 'zarr.json'));
+    if (!v3)
+        throw new Error(`zarr ${path}: no array metadata`);
+    const m = JSON.parse(await v3.text());
+    if (m.chunk_grid?.name !== 'regular')
+        throw new Error(`zarr ${path}: chunk grid ${m.chunk_grid?.name} is not supported`);
+    const codecs = (m.codecs ?? []);
+    const bytes = codecs[0];
+    if (bytes?.name !== 'bytes') {
+        throw new Error(`zarr ${path}: codec ${bytes?.name ?? 'none'} before bytes is not supported (sharding, transpose)`);
+    }
+    const little = (bytes.configuration?.['endian'] ?? 'little') === 'little';
+    const enc = m.chunk_key_encoding ?? { name: 'default' };
+    const sep = enc.configuration?.separator ?? (enc.name === 'v2' ? '.' : '/');
+    return {
+        shape: m.shape,
+        chunks: m.chunk_grid.configuration.chunk_shape,
+        dtype: v3Dtype(m.data_type, little, path),
+        codecs: codecs.slice(1).map((c) => ({ id: c.name, ...(c.configuration ?? {}) })),
+        fill: Number(m.fill_value ?? 0) || 0,
+        key: (index) => (enc.name === 'v2' ? index.join(sep) : ['c', ...index].join(sep)),
+    };
+}
+/** The slices of the array at `path`, decoding (and keeping) the chunk layers a slice spans. */
+function labelStack(byPath, path, a, axes, inflate) {
+    const { ix, iy, iz } = axes;
+    const width = a.shape[ix];
+    const height = a.shape[iy];
+    const slices = iz < 0 ? 1 : a.shape[iz];
+    const cx = a.chunks[ix];
+    const cy = a.chunks[iy];
+    // The chunks (their decodes, pending or done) of the last chunk layer along z read: a slice's
+    // neighbours share it. A read keeps the layer it started with, so a read of another layer
+    // replacing this cache while it awaits a chunk cannot change what it reads.
+    let layer = null;
+    const chunk = async (index) => {
+        const file = byPath.get(join(path, a.key(index)));
+        if (!file)
+            return null;
+        return decodeChunk(await file.bytes(), a.codecs, inflate);
+    };
+    return {
+        width,
+        height,
+        slices,
+        async labels(z) {
+            if (z < 0 || z >= slices)
+                throw new Error(`slice ${z} of ${slices}`);
+            const kz = iz < 0 ? 0 : Math.floor(z / a.chunks[iz]);
+            if (layer?.kz !== kz)
+                layer = { kz, chunks: new Map() };
+            const mine = layer;
+            const out = new Uint32Array(width * height);
+            const strides = a.chunks.map((_, d) => a.chunks.slice(d + 1).reduce((p, n) => p * n, 1));
+            for (let gy = 0; gy * cy < height; gy++) {
+                for (let gx = 0; gx * cx < width; gx++) {
+                    // Every other axis (time, channel) at its first index.
+                    const index = a.shape.map((_, d) => (d === ix ? gx : d === iy ? gy : d === iz ? kz : 0));
+                    const key = index.join(',');
+                    let pending = mine.chunks.get(key);
+                    if (!pending) {
+                        pending = chunk(index);
+                        mine.chunks.set(key, pending);
+                        // A chunk that failed to decode is not kept: the next read tries it again.
+                        pending.catch(() => mine.chunks.delete(key));
+                    }
+                    const data = await pending;
+                    const view = data ? new DataView(data.buffer, data.byteOffset, data.byteLength) : null;
+                    const inZ = iz < 0 ? 0 : z - kz * a.chunks[iz];
+                    for (let y = gy * cy; y < Math.min(height, (gy + 1) * cy); y++) {
+                        for (let x = gx * cx; x < Math.min(width, (gx + 1) * cx); x++) {
+                            let v = a.fill;
+                            if (view) {
+                                const local = a.shape.map((_, d) => d === ix ? x - gx * cx : d === iy ? y - gy * cy : d === iz ? inZ : 0);
+                                const i = local.reduce((p, n, d) => p + n * strides[d], 0);
+                                v = a.dtype.read(view, i * a.dtype.bytes);
+                            }
+                            if (v > 0xffffffff) {
+                                // A label id past 32 bits would be another label once narrowed: refuse it.
+                                throw new Error(`zarr ${path}: label ${v} does not fit 32 bits`);
+                            }
+                            out[y * width + x] = v > 0 ? v : 0;
+                        }
+                    }
+                }
+            }
+            return out;
+        },
+    };
+}
+const SAMPLE = {
+    u1: { bytes: 1, read: (v, at) => v.getUint8(at) },
+    i1: { bytes: 1, read: (v, at) => v.getInt8(at) },
+    u2: { bytes: 2, read: (v, at, le) => v.getUint16(at, le) },
+    i2: { bytes: 2, read: (v, at, le) => v.getInt16(at, le) },
+    u4: { bytes: 4, read: (v, at, le) => v.getUint32(at, le) },
+    i4: { bytes: 4, read: (v, at, le) => v.getInt32(at, le) },
+    u8: { bytes: 8, read: (v, at, le) => Number(v.getBigUint64(at, le)) },
+    i8: { bytes: 8, read: (v, at, le) => Number(v.getBigInt64(at, le)) },
+    f4: { bytes: 4, read: (v, at, le) => Math.round(v.getFloat32(at, le)) },
+    f8: { bytes: 8, read: (v, at, le) => Math.round(v.getFloat64(at, le)) },
+};
+function v2Dtype(dtype, path) {
+    const m = /^([<>|])([uif])(\d)$/.exec(dtype);
+    const s = m ? SAMPLE[m[2] + m[3]] : undefined;
+    if (!m || !s)
+        throw new Error(`zarr ${path}: dtype ${dtype} is not a label type`);
+    const le = m[1] !== '>';
+    return { bytes: s.bytes, read: (v, at) => s.read(v, at, le) };
+}
+function v3Dtype(type, little, path) {
+    const m = /^(u?int|float)(8|16|32|64)$/.exec(type);
+    const code = m ? (m[1] === 'uint' ? 'u' : m[1] === 'int' ? 'i' : 'f') + Number(m[2]) / 8 : '';
+    const s = SAMPLE[code];
+    if (!s)
+        throw new Error(`zarr ${path}: data type ${type} is not a label type`);
+    return { bytes: s.bytes, read: (v, at) => s.read(v, at, little) };
+}
+/** The classes `image-label` names (a property naming each value) and colours; others unnamed. */
+function imageLabelClasses(meta) {
+    const named = new Map();
+    for (const p of meta?.properties ?? []) {
+        const name = ['name', 'class', 'label', 'acronym', 'structure', 'type']
+            .map((k) => p[k])
+            .find((v) => typeof v === 'string');
+        named.set(p['label-value'], { ...named.get(p['label-value']), name: name });
+    }
+    for (const c of meta?.colors ?? []) {
+        if (!c.rgba)
+            continue;
+        const hex = `#${c.rgba
+            .slice(0, 3)
+            .map((n) => Math.round(n).toString(16).padStart(2, '0'))
+            .join('')}`.toUpperCase();
+        named.set(c['label-value'], { ...named.get(c['label-value']), color: hex });
+    }
+    if (!named.size)
+        return labelClasses(undefined);
+    const classHierarchy = [];
+    const seen = new Set();
+    for (const [value, { name, color }] of named) {
+        const cls = name ?? `label ${value}`;
+        // One class per name: an instance segmentation names many values alike.
+        if (!seen.has(cls))
+            classHierarchy.push({ name: cls, ...(color ? { color } : {}), value });
+        seen.add(cls);
+    }
+    const labels = Object.fromEntries([...named].map(([v, { name }]) => [v, name ?? `label ${v}`]));
+    return labelClasses({ classHierarchy, labels });
+}
+function unitToMicrons(unit) {
+    switch (unit?.toLowerCase()) {
+        case 'nanometer':
+            return 1e-3;
+        case 'millimeter':
+            return 1e3;
+        case 'centimeter':
+            return 1e4;
+        case 'meter':
+            return 1e6;
+        default:
+            return 1; // micrometer, or none said
+    }
+}
+/** A path relative to the store, '/'-separated, without a leading './'. */
+function norm(name) {
+    return name.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+function join(dir, name) {
+    return dir ? `${dir}/${name}` : name;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ome-zarr-labels.js","sourceRoot":"","sources":["../../../../src/lib/region-import/ome-zarr-labels.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A label image of an OME-Zarr store (`labels/<name>/`, NGFF 0.4 on zarr v2 or 0.5 on zarr v3),\n * read in the browser from the store's files (a folder chosen, or a zip's members): its full\n * resolution level, sliced along z, with the classes its `image-label` metadata names and colours.\n *\n * Chunks are decoded when a slice that needs them is read, so a store is never decoded whole.\n * Only what label images use: C-order chunks of integer (or integer-valued float) samples, through\n * the codecs {@link decodeChunk} reads, a missing chunk being the fill value. Sharded or transposed\n * arrays, F-order and filters throw rather than be read wrongly. Pure: usable from workers.\n */\nimport { labelClasses, LabelClasses } from './label-classes';\nimport type { RegionImportFile } from './region-import';\nimport { decodeChunk, Inflate } from './zarr-codecs';\n\n/** A stack of label slices read on demand. Label 0 is background. */\nexport interface LabelStack {\n  width: number;\n  height: number;\n  slices: number;\n  /** Size of a voxel, x, y, z, in micrometres, when the source says. */\n  spacing?: [number, number, number];\n  /** Slice `z`'s labels, row-major (`height` rows of `width`). */\n  labels(z: number): Promise<Uint32Array>;\n}\n\n/** An OME-Zarr label image: its name, its slices, its classes. */\nexport interface OmeZarrLabels {\n  name: string;\n  stack: LabelStack;\n  classes: LabelClasses;\n}\n\n/** Whether `files` hold a zarr store (any zarr metadata among them). */\nexport function hasZarrMetadata(files: readonly RegionImportFile[]): boolean {\n  return files.some((f) => /(^|\\/)(\\.zattrs|\\.zarray|\\.zgroup|zarr\\.json)$/.test(norm(f.name)));\n}\n\n/**\n * The first label image of the zarr store among `files` (the order `labels/`'s listing gives,\n * else the first found), or null when the store has none.\n */\nexport async function readOmeZarrLabels(\n  files: readonly RegionImportFile[],\n  inflate?: Inflate,\n): Promise<OmeZarrLabels | null> {\n  const byPath = new Map(files.map((f) => [norm(f.name), f]));\n  const groups = new Map<string, Record<string, unknown>>();\n  for (const [path, file] of byPath) {\n    const m = /^(.*?)\\/?(\\.zattrs|zarr\\.json)$/.exec(path);\n    if (!m) continue;\n    const doc = JSON.parse(await file.text()) as Record<string, unknown>;\n    const attrs = (m[2] === 'zarr.json' ? (doc['attributes'] as Record<string, unknown>) : doc) ?? {};\n    groups.set(m[1], ((attrs['ome'] as Record<string, unknown>) ?? attrs) as Record<string, unknown>);\n  }\n  const listed: string[] = [];\n  for (const [dir, ome] of groups) {\n    for (const name of (ome['labels'] as string[] | undefined) ?? []) listed.push(join(dir, name));\n  }\n  const isLabel = (dir: string) => {\n    const ome = groups.get(dir);\n    return !!ome?.['multiscales'] && (!!ome['image-label'] || /(^|\\/)labels\\/[^/]+$/.test(dir));\n  };\n  const dir = [...listed, ...groups.keys()].find(isLabel);\n  if (dir === undefined) return null;\n  const ome = groups.get(dir) as Record<string, unknown>;\n  const ms = (ome['multiscales'] as Multiscale[])[0];\n  const dataset = ms.datasets[0];\n  const array = await readArrayMeta(byPath, join(dir, dataset.path));\n  const axes = (ms.axes ?? ['z', 'y', 'x'].slice(3 - array.shape.length)).map((a) =>\n    typeof a === 'string' ? { name: a } : a,\n  );\n  if (axes.length !== array.shape.length)\n    throw new Error(`OME-Zarr ${dir}: ${axes.length} axes for a ${array.shape.length}-D array`);\n  const at = (n: string) => axes.findIndex((a) => a.name.toLowerCase() === n);\n  const ix = at('x');\n  const iy = at('y');\n  const iz = at('z');\n  if (ix < 0 || iy < 0) throw new Error(`OME-Zarr ${dir}: no x and y axes`);\n  const scale = dataset.coordinateTransformations?.find((t) => t.type === 'scale')?.scale;\n  const um = (i: number) => (i < 0 ? 1 : (scale?.[i] ?? 1) * unitToMicrons(axes[i].unit));\n  const stack = labelStack(byPath, join(dir, dataset.path), array, { ix, iy, iz }, inflate);\n  stack.spacing = [um(ix), um(iy), iz < 0 ? 1 : um(iz)];\n  const name = ms.name ?? dir.split('/').pop() ?? 'labels';\n  return { name, stack, classes: imageLabelClasses(ome['image-label'] as ImageLabel | undefined) };\n}\n\ninterface Multiscale {\n  name?: string;\n  axes?: Array<string | { name: string; type?: string; unit?: string }>;\n  datasets: Array<{ path: string; coordinateTransformations?: Array<{ type: string; scale?: number[] }> }>;\n}\n\ninterface ImageLabel {\n  colors?: Array<{ 'label-value': number; rgba?: number[] }>;\n  properties?: Array<Record<string, unknown> & { 'label-value': number }>;\n}\n\n/** What one array's chunks are and how they decode. */\ninterface ArrayMeta {\n  shape: number[];\n  chunks: number[];\n  /** Sample reader: element `i` of a decoded chunk. */\n  dtype: { bytes: number; read: (v: DataView, at: number) => number };\n  codecs: { id: string }[];\n  fill: number;\n  key: (index: number[]) => string;\n}\n\nasync function readArrayMeta(byPath: Map<string, RegionImportFile>, path: string): Promise<ArrayMeta> {\n  const v2 = byPath.get(join(path, '.zarray'));\n  if (v2) {\n    const m = JSON.parse(await v2.text());\n    if (m.order && m.order !== 'C') throw new Error(`zarr ${path}: ${m.order}-order chunks are not supported`);\n    if (m.filters?.length) throw new Error(`zarr ${path}: filters are not supported`);\n    const sep = m.dimension_separator ?? '.';\n    return {\n      shape: m.shape,\n      chunks: m.chunks,\n      dtype: v2Dtype(m.dtype, path),\n      codecs: m.compressor ? [m.compressor] : [],\n      fill: Number(m.fill_value ?? 0) || 0,\n      key: (index) => index.join(sep),\n    };\n  }\n  const v3 = byPath.get(join(path, 'zarr.json'));\n  if (!v3) throw new Error(`zarr ${path}: no array metadata`);\n  const m = JSON.parse(await v3.text());\n  if (m.chunk_grid?.name !== 'regular')\n    throw new Error(`zarr ${path}: chunk grid ${m.chunk_grid?.name} is not supported`);\n  const codecs = (m.codecs ?? []) as Array<{ name: string; configuration?: Record<string, unknown> }>;\n  const bytes = codecs[0];\n  if (bytes?.name !== 'bytes') {\n    throw new Error(\n      `zarr ${path}: codec ${bytes?.name ?? 'none'} before bytes is not supported (sharding, transpose)`,\n    );\n  }\n  const little = (bytes.configuration?.['endian'] ?? 'little') === 'little';\n  const enc = m.chunk_key_encoding ?? { name: 'default' };\n  const sep = (enc.configuration?.separator as string) ?? (enc.name === 'v2' ? '.' : '/');\n  return {\n    shape: m.shape,\n    chunks: m.chunk_grid.configuration.chunk_shape,\n    dtype: v3Dtype(m.data_type, little, path),\n    codecs: codecs.slice(1).map((c) => ({ id: c.name, ...(c.configuration ?? {}) })),\n    fill: Number(m.fill_value ?? 0) || 0,\n    key: (index) => (enc.name === 'v2' ? index.join(sep) : ['c', ...index].join(sep)),\n  };\n}\n\n/** The slices of the array at `path`, decoding (and keeping) the chunk layers a slice spans. */\nfunction labelStack(\n  byPath: Map<string, RegionImportFile>,\n  path: string,\n  a: ArrayMeta,\n  axes: { ix: number; iy: number; iz: number },\n  inflate?: Inflate,\n): LabelStack {\n  const { ix, iy, iz } = axes;\n  const width = a.shape[ix];\n  const height = a.shape[iy];\n  const slices = iz < 0 ? 1 : a.shape[iz];\n  const cx = a.chunks[ix];\n  const cy = a.chunks[iy];\n  // The chunks (their decodes, pending or done) of the last chunk layer along z read: a slice's\n  // neighbours share it. A read keeps the layer it started with, so a read of another layer\n  // replacing this cache while it awaits a chunk cannot change what it reads.\n  let layer: { kz: number; chunks: Map<string, Promise<Uint8Array | null>> } | null = null;\n  const chunk = async (index: number[]): Promise<Uint8Array | null> => {\n    const file = byPath.get(join(path, a.key(index)));\n    if (!file) return null;\n    return decodeChunk(await file.bytes(), a.codecs, inflate);\n  };\n  return {\n    width,\n    height,\n    slices,\n    async labels(z: number): Promise<Uint32Array> {\n      if (z < 0 || z >= slices) throw new Error(`slice ${z} of ${slices}`);\n      const kz = iz < 0 ? 0 : Math.floor(z / a.chunks[iz]);\n      if (layer?.kz !== kz) layer = { kz, chunks: new Map() };\n      const mine = layer;\n      const out = new Uint32Array(width * height);\n      const strides = a.chunks.map((_, d) => a.chunks.slice(d + 1).reduce((p, n) => p * n, 1));\n      for (let gy = 0; gy * cy < height; gy++) {\n        for (let gx = 0; gx * cx < width; gx++) {\n          // Every other axis (time, channel) at its first index.\n          const index = a.shape.map((_, d) => (d === ix ? gx : d === iy ? gy : d === iz ? kz : 0));\n          const key = index.join(',');\n          let pending = mine.chunks.get(key);\n          if (!pending) {\n            pending = chunk(index);\n            mine.chunks.set(key, pending);\n            // A chunk that failed to decode is not kept: the next read tries it again.\n            pending.catch(() => mine.chunks.delete(key));\n          }\n          const data = await pending;\n          const view = data ? new DataView(data.buffer, data.byteOffset, data.byteLength) : null;\n          const inZ = iz < 0 ? 0 : z - kz * a.chunks[iz];\n          for (let y = gy * cy; y < Math.min(height, (gy + 1) * cy); y++) {\n            for (let x = gx * cx; x < Math.min(width, (gx + 1) * cx); x++) {\n              let v = a.fill;\n              if (view) {\n                const local = a.shape.map((_, d) =>\n                  d === ix ? x - gx * cx : d === iy ? y - gy * cy : d === iz ? inZ : 0,\n                );\n                const i = local.reduce((p, n, d) => p + n * strides[d], 0);\n                v = a.dtype.read(view, i * a.dtype.bytes);\n              }\n              if (v > 0xffffffff) {\n                // A label id past 32 bits would be another label once narrowed: refuse it.\n                throw new Error(`zarr ${path}: label ${v} does not fit 32 bits`);\n              }\n              out[y * width + x] = v > 0 ? v : 0;\n            }\n          }\n        }\n      }\n      return out;\n    },\n  };\n}\n\nconst SAMPLE: Record<string, { bytes: number; read: (v: DataView, at: number, le: boolean) => number }> = {\n  u1: { bytes: 1, read: (v, at) => v.getUint8(at) },\n  i1: { bytes: 1, read: (v, at) => v.getInt8(at) },\n  u2: { bytes: 2, read: (v, at, le) => v.getUint16(at, le) },\n  i2: { bytes: 2, read: (v, at, le) => v.getInt16(at, le) },\n  u4: { bytes: 4, read: (v, at, le) => v.getUint32(at, le) },\n  i4: { bytes: 4, read: (v, at, le) => v.getInt32(at, le) },\n  u8: { bytes: 8, read: (v, at, le) => Number(v.getBigUint64(at, le)) },\n  i8: { bytes: 8, read: (v, at, le) => Number(v.getBigInt64(at, le)) },\n  f4: { bytes: 4, read: (v, at, le) => Math.round(v.getFloat32(at, le)) },\n  f8: { bytes: 8, read: (v, at, le) => Math.round(v.getFloat64(at, le)) },\n};\n\nfunction v2Dtype(dtype: string, path: string): ArrayMeta['dtype'] {\n  const m = /^([<>|])([uif])(\\d)$/.exec(dtype);\n  const s = m ? SAMPLE[m[2] + m[3]] : undefined;\n  if (!m || !s) throw new Error(`zarr ${path}: dtype ${dtype} is not a label type`);\n  const le = m[1] !== '>';\n  return { bytes: s.bytes, read: (v, at) => s.read(v, at, le) };\n}\n\nfunction v3Dtype(type: string, little: boolean, path: string): ArrayMeta['dtype'] {\n  const m = /^(u?int|float)(8|16|32|64)$/.exec(type);\n  const code = m ? (m[1] === 'uint' ? 'u' : m[1] === 'int' ? 'i' : 'f') + Number(m[2]) / 8 : '';\n  const s = SAMPLE[code];\n  if (!s) throw new Error(`zarr ${path}: data type ${type} is not a label type`);\n  return { bytes: s.bytes, read: (v, at) => s.read(v, at, little) };\n}\n\n/** The classes `image-label` names (a property naming each value) and colours; others unnamed. */\nfunction imageLabelClasses(meta: ImageLabel | undefined): LabelClasses {\n  const named = new Map<number, { name?: string; color?: string }>();\n  for (const p of meta?.properties ?? []) {\n    const name = ['name', 'class', 'label', 'acronym', 'structure', 'type']\n      .map((k) => p[k])\n      .find((v) => typeof v === 'string');\n    named.set(p['label-value'], { ...named.get(p['label-value']), name: name as string | undefined });\n  }\n  for (const c of meta?.colors ?? []) {\n    if (!c.rgba) continue;\n    const hex = `#${c.rgba\n      .slice(0, 3)\n      .map((n) => Math.round(n).toString(16).padStart(2, '0'))\n      .join('')}`.toUpperCase();\n    named.set(c['label-value'], { ...named.get(c['label-value']), color: hex });\n  }\n  if (!named.size) return labelClasses(undefined);\n  const classHierarchy: Array<{ name: string; color?: string; value: number }> = [];\n  const seen = new Set<string>();\n  for (const [value, { name, color }] of named) {\n    const cls = name ?? `label ${value}`;\n    // One class per name: an instance segmentation names many values alike.\n    if (!seen.has(cls)) classHierarchy.push({ name: cls, ...(color ? { color } : {}), value });\n    seen.add(cls);\n  }\n  const labels = Object.fromEntries([...named].map(([v, { name }]) => [v, name ?? `label ${v}`]));\n  return labelClasses({ classHierarchy, labels });\n}\n\nfunction unitToMicrons(unit: string | undefined): number {\n  switch (unit?.toLowerCase()) {\n    case 'nanometer':\n      return 1e-3;\n    case 'millimeter':\n      return 1e3;\n    case 'centimeter':\n      return 1e4;\n    case 'meter':\n      return 1e6;\n    default:\n      return 1; // micrometer, or none said\n  }\n}\n\n/** A path relative to the store, '/'-separated, without a leading './'. */\nfunction norm(name: string): string {\n  return name.replace(/\\\\/g, '/').replace(/^\\.\\//, '');\n}\n\nfunction join(dir: string, name: string): string {\n  return dir ? `${dir}/${name}` : name;\n}\n"]}