@niivue/nv-ext-tile 1.0.0-rc.7 → 1.0.0-rc.8

package/README.md

@@ -101,7 +101,8 @@ const slide = NVSlide.fromSource(new DicomWsiSource(index.slides[0], files))
   that changed since indexing fails rather than decoding garbage.
 - Supported transfer syntaxes: JPEG baseline/extended (browser), JPEG 2000 and JPEG-LS
   (`registerDcm2niixDecoders`, with `@niivue/dcm2niix` as an optional peer dependency;
-  a decoder the host already registered wins).
+  a decoder the host already registered wins). A dcm2niix pool whose workers die is
+  replaced, and the tile or profile retried once.
 - Slides are shown with row 0 of the total pixel matrix at the top (`displayYAxis: 'down'`),
   as OpenSlide shows them.
 - Index speed for the 8 OpenSlide DICOM-WSI test sets (local SSD; Chrome reads through

package/dist/dcm2niixDecoders.d.ts

@@ -1,3 +1,10 @@
+import { FrameDecoder } from '@niivue/dcm2niix';
+import { SlideIccTransform, SlideTileDecoder } from '@niivue/niivue';
+/** Tile decoder and ICC transform over one lazily created dcm2niix pool, replaced when its workers die. */
+export declare function createDcm2niixDecoders(createDecoder?: () => Promise<FrameDecoder>): {
+    decodeTile: SlideTileDecoder;
+    bakeProfile: SlideIccTransform;
+};
 /**
  * Register JPEG 2000 and JPEG-LS tile decoders for NVSlide, backed by dcm2niix's
  * WASM worker pool (loaded on the first such tile), and its LittleCMS ICC

package/dist/dicom.js

@@ -1,117 +1,151 @@
 import { NVSlide as q } from "@niivue/niivue";
-let J = null;
-const wt = () => (J ?? (J = import("@niivue/dcm2niix").then((e) => e.createFrameDecoder({ workers: 2 })).catch((e) => {
-  throw J = null, e;
-})), J), ft = 33, Et = async (e, t) => {
-  const s = await (await wt()).iccLut(e, { size: ft, signal: t });
-  return s && { size: ft, data: s };
-}, xt = async (e, { level: t, signal: r }) => {
-  var o;
-  const s = await wt(), n = {
-    photometric: t.photometric,
-    bitsStored: t.bitsStored,
-    signal: r
+function $t(e) {
+  return e instanceof Error && e.name === "Error" && !e.message.startsWith("frame decoder ");
+}
+const ct = 33;
+function Mt(e = () => import("@niivue/dcm2niix").then(
+  (t) => t.createFrameDecoder({ workers: 2 })
+)) {
+  let t = null;
+  const r = () => {
+    const a = {
+      active: 0,
+      retired: !1,
+      decoder: e().catch((n) => {
+        throw t === a && (t = null), n;
+      })
+    };
+    return a;
+  }, s = async (a, n, l = !1) => {
+    t ?? (t = r());
+    const f = t;
+    f.active++;
+    try {
+      return await n(await f.decoder);
+    } catch (d) {
+      if (d !== (a == null ? void 0 : a.reason) && $t(d) && (f.retired = !0, t === f && (t = null), !l && !(a != null && a.aborted)))
+        return s(a, n, !0);
+      throw d;
+    } finally {
+      --f.active === 0 && f.retired && f.decoder.then(
+        (d) => d.terminate(),
+        () => {
+        }
+      );
+    }
   };
-  if ((o = t.photometric) != null && o.startsWith("MONOCHROME"))
-    return s.decode(e, { ...n, output: "samples" });
-  const i = await s.decode(e, n), c = i.rgba;
-  return createImageBitmap(new ImageData(c, i.width, i.height));
-};
-function Tt() {
-  for (const e of ["image/jp2", "image/jls"])
-    q.tileDecoder(e) || q.registerTileDecoder(e, xt);
-  q.iccTransform() || q.registerIccTransform(Et);
+  return { decodeTile: (a, { level: n, signal: l }) => s(l, async (f) => {
+    var u;
+    const d = {
+      photometric: n.photometric,
+      bitsStored: n.bitsStored,
+      signal: l
+    };
+    if ((u = n.photometric) != null && u.startsWith("MONOCHROME"))
+      return f.decode(a, { ...d, output: "samples" });
+    const m = await f.decode(a, d), h = m.rgba;
+    return createImageBitmap(new ImageData(h, m.width, m.height));
+  }), bakeProfile: (a, n) => s(n, async (l) => {
+    const f = await l.iccLut(a, { size: ct, signal: n });
+    return f && { size: ct, data: f };
+  }) };
 }
-const et = (e) => e.webkitRelativePath || e.name, _ = 4294967295, lt = 8, K = 64 << 20, Q = 1 << 22, ht = 2 * Q, mt = 4096, Pt = { US: 2, UL: 4, SL: 4 }, d = (e, t) => (e << 16 | t) >>> 0, m = {
-  transferSyntax: d(2, 16),
-  imageType: d(8, 8),
-  sop: d(8, 24),
-  study: d(32, 13),
-  series: d(32, 14),
-  frameOfReference: d(32, 82),
-  organization: d(32, 37649),
-  concatNumber: d(32, 37218),
-  concatOffset: d(32, 37416),
-  photometric: d(40, 4),
-  frames: d(40, 8),
-  rows: d(40, 16),
-  columns: d(40, 17),
-  spacing: d(40, 48),
-  bitsStored: d(40, 257),
-  iccProfile: d(40, 8192),
-  colorSpace: d(40, 8194),
-  container: d(64, 1298),
-  zOffset: d(64, 1866),
-  totalColumns: d(72, 6),
-  totalRows: d(72, 7),
-  opticalPathSeq: d(72, 261),
-  opticalPathId: d(72, 262),
-  columnPosition: d(72, 542),
-  rowPosition: d(72, 543),
-  opticalPaths: d(72, 770),
-  focalPlanes: d(72, 771),
-  shared: d(20992, 37417),
-  perFrame: d(20992, 37424),
-  eot: d(32736, 1),
-  eotLengths: d(32736, 2),
-  pixelData: d(32736, 16),
-  item: d(65534, 57344),
-  itemEnd: d(65534, 57357),
-  sequenceEnd: d(65534, 57565)
-}, bt = new Set("OB OD OF OL OV OW SQ SV UC UN UR UT UV".split(" ")), Ut = /* @__PURE__ */ new Set([
+function vt() {
+  const { decodeTile: e, bakeProfile: t } = Mt();
+  for (const r of ["image/jp2", "image/jls"])
+    q.tileDecoder(r) || q.registerTileDecoder(r, e);
+  q.iccTransform() || q.registerIccTransform(t);
+}
+const tt = (e) => e.webkitRelativePath || e.name, k = 4294967295, ft = 8, J = 64 << 20, K = 1 << 22, lt = 2 * K, ht = 4096, Et = { US: 2, UL: 4, SL: 4 }, p = (e, t) => (e << 16 | t) >>> 0, w = {
+  transferSyntax: p(2, 16),
+  imageType: p(8, 8),
+  sop: p(8, 24),
+  study: p(32, 13),
+  series: p(32, 14),
+  frameOfReference: p(32, 82),
+  organization: p(32, 37649),
+  concatNumber: p(32, 37218),
+  concatOffset: p(32, 37416),
+  photometric: p(40, 4),
+  frames: p(40, 8),
+  rows: p(40, 16),
+  columns: p(40, 17),
+  spacing: p(40, 48),
+  bitsStored: p(40, 257),
+  iccProfile: p(40, 8192),
+  colorSpace: p(40, 8194),
+  container: p(64, 1298),
+  zOffset: p(64, 1866),
+  totalColumns: p(72, 6),
+  totalRows: p(72, 7),
+  opticalPathSeq: p(72, 261),
+  opticalPathId: p(72, 262),
+  columnPosition: p(72, 542),
+  rowPosition: p(72, 543),
+  opticalPaths: p(72, 770),
+  focalPlanes: p(72, 771),
+  shared: p(20992, 37417),
+  perFrame: p(20992, 37424),
+  eot: p(32736, 1),
+  eotLengths: p(32736, 2),
+  pixelData: p(32736, 16),
+  item: p(65534, 57344),
+  itemEnd: p(65534, 57357),
+  sequenceEnd: p(65534, 57565)
+}, Pt = new Set("OB OD OF OL OV OW SQ SV UC UN UR UT UV".split(" ")), bt = /* @__PURE__ */ new Set([
   "1.2.840.10008.1.2",
   "1.2.840.10008.1.2.2",
   "1.2.840.10008.1.2.1.99"
 ]);
-class x extends Error {
+class P extends Error {
   constructor(t, r) {
     super(r), this.reason = t;
   }
 }
-class W extends Error {
+class z extends Error {
 }
 function A(e, t) {
-  if (t + 2 > e.length) throw new W();
+  if (t + 2 > e.length) throw new z();
   return e[t] | e[t + 1] << 8;
 }
 function v(e, t) {
-  if (t + 4 > e.length) throw new W();
+  if (t + 4 > e.length) throw new z();
   return (e[t] | e[t + 1] << 8 | e[t + 2] << 16 | e[t + 3] << 24) >>> 0;
 }
-function dt(e, t, r, s, n, i) {
+function ut(e, t, r, s, o, c) {
   for (; t < r; ) {
-    const c = d(A(e, t), A(e, t + 2));
-    if (c === m.itemEnd || c === m.sequenceEnd) return t + 8;
-    if (n.depth === 0 && c === m.pixelData) return t;
-    const o = String.fromCharCode(e[t + 4], e[t + 5]);
-    if (!/^[A-Z]{2}$/.test(o))
-      throw new x("malformed", `no explicit VR at byte ${t}`);
-    const f = bt.has(o), h = f ? v(e, t + 8) : A(e, t + 6), p = t + (f ? 12 : 8);
-    if (o === "SQ" || o === "UN" && h === _) {
-      if (n.depth >= lt)
-        throw new x("malformed", `sequences nested deeper than ${lt}`);
-      const u = h === _ ? s : p + h;
-      let l = p;
-      for (let w = 0; l < u; w++) {
-        const E = d(A(e, l), A(e, l + 2));
-        if (E === m.sequenceEnd) {
-          l += 8;
+    const a = p(A(e, t), A(e, t + 2));
+    if (a === w.itemEnd || a === w.sequenceEnd) return t + 8;
+    if (o.depth === 0 && a === w.pixelData) return t;
+    const n = String.fromCharCode(e[t + 4], e[t + 5]);
+    if (!/^[A-Z]{2}$/.test(n))
+      throw new P("malformed", `no explicit VR at byte ${t}`);
+    const l = Pt.has(n), f = l ? v(e, t + 8) : A(e, t + 6), d = t + (l ? 12 : 8);
+    if (n === "SQ" || n === "UN" && f === k) {
+      if (o.depth >= ft)
+        throw new P("malformed", `sequences nested deeper than ${ft}`);
+      const m = f === k ? s : d + f;
+      let h = d;
+      for (let u = 0; h < m; u++) {
+        const E = p(A(e, h), A(e, h + 2));
+        if (E === w.sequenceEnd) {
+          h += 8;
           break;
         }
-        if (E !== m.item)
-          throw new x("malformed", `no item at byte ${l}`);
-        const y = v(e, l + 4), S = y === _ ? s : l + 8 + y, U = n.depth === 0 ? { root: c, item: w, depth: 1 } : { ...n, depth: n.depth + 1 }, I = dt(e, l + 8, S, s, U, i);
-        l = y === _ ? I : S;
+        if (E !== w.item)
+          throw new P("malformed", `no item at byte ${h}`);
+        const y = v(e, h + 4), S = y === k ? s : h + 8 + y, U = o.depth === 0 ? { root: a, item: u, depth: 1 } : { ...o, depth: o.depth + 1 }, I = ut(e, h + 8, S, s, U, c);
+        h = y === k ? I : S;
       }
-      t = l;
+      t = h;
       continue;
     }
-    if (h === _)
-      throw new x("malformed", `undefined-length ${o} at byte ${t}`);
-    if (p + h > s)
-      throw new x("malformed", `${o} at byte ${t} runs past the file`);
-    if (p + h > e.length) throw new W();
-    i({ tag: c, vr: o, offset: p, length: h, ...n }), t = p + h;
+    if (f === k)
+      throw new P("malformed", `undefined-length ${n} at byte ${t}`);
+    if (d + f > s)
+      throw new P("malformed", `${n} at byte ${t} runs past the file`);
+    if (d + f > e.length) throw new z();
+    c({ tag: a, vr: n, offset: d, length: f, ...o }), t = d + f;
   }
   return t;
 }
@@ -119,405 +153,405 @@ const N = (e, t) => String.fromCharCode(...e.subarray(t.offset, t.offset + t.len
   /[\0 ]+$/,
   ""
 );
-function z(e, t) {
-  const r = Pt[t.vr];
+function W(e, t) {
+  const r = Et[t.vr];
   if (!r) return Number(N(e, t).split("\\")[0]);
   if (t.length < r) return Number.NaN;
   const s = new DataView(e.buffer, e.byteOffset + t.offset, r);
   return t.vr === "US" ? s.getUint16(0, !0) : t.vr === "UL" ? s.getUint32(0, !0) : s.getInt32(0, !0);
 }
-function ut(e, t) {
-  const r = t.find((s) => s.tag === m.transferSyntax);
-  if (r && Ut.has(N(e, r)))
-    throw new x(
+function mt(e, t) {
+  const r = t.find((s) => s.tag === w.transferSyntax);
+  if (r && bt.has(N(e, r)))
+    throw new P(
       "transfer-syntax",
       `transfer syntax ${N(e, r)} is not explicit VR little endian`
     );
 }
-async function Ot(e, t) {
+async function xt(e, t) {
   let r = Math.min(t, 1048576), s = new Uint8Array(0);
   for (; ; ) {
-    const n = await e(s.length, r - s.length), i = new Uint8Array(r);
-    i.set(s), i.set(n, s.length), s = i;
-    const c = [];
+    const o = await e(s.length, r - s.length), c = new Uint8Array(r);
+    c.set(s), c.set(o, s.length), s = c;
+    const a = [];
     try {
       if (String.fromCharCode(...s.subarray(128, 132)) !== "DICM")
-        throw new x("not-dicom", "no DICM preamble");
-      const o = dt(
+        throw new P("not-dicom", "no DICM preamble");
+      const n = ut(
         s,
         132,
         t,
         t,
         { root: 0, item: 0, depth: 0 },
-        (f) => c.push(f)
+        (l) => a.push(l)
       );
-      if (o + 20 > s.length) throw new W();
-      return ut(s, c), { b: s, pixel: o, elements: c };
-    } catch (o) {
-      if (ut(s, c), !(o instanceof W)) throw o;
+      if (n + 20 > s.length) throw new z();
+      return mt(s, a), { b: s, pixel: n, elements: a };
+    } catch (n) {
+      if (mt(s, a), !(n instanceof z)) throw n;
       if (r >= t)
-        throw new x("not-tiled", "no Pixel Data (e.g. a DICOMDIR)");
-      if (r >= K)
-        throw new x("malformed", `header over ${K >> 20} MiB`);
-      r = Math.min(t, K, r * 4);
+        throw new P("not-tiled", "no Pixel Data (e.g. a DICOMDIR)");
+      if (r >= J)
+        throw new P("malformed", `header over ${J >> 20} MiB`);
+      r = Math.min(t, J, r * 4);
     }
   }
 }
-async function At(e) {
-  const t = e.size, r = async (a, g) => new Uint8Array(await e.slice(a, a + g).arrayBuffer()), { b: s, pixel: n, elements: i } = await Ot(r, t), c = /* @__PURE__ */ new Map(), o = [], f = [], h = [];
-  let p, u, l, w = 0, E = !1;
-  for (const a of i)
-    a.depth === 0 ? c.set(a.tag, a) : a.root === m.opticalPathSeq && a.depth === 1 ? (a.tag === m.opticalPathId && (o[a.item] = N(s, a)), a.tag === m.iccProfile && (f[a.item] = { offset: a.offset, length: a.length }), a.tag === m.colorSpace && (h[a.item] = N(s, a))) : a.root === m.shared ? (a.tag === m.spacing && (p = N(s, a)), a.tag === m.opticalPathId && (u = N(s, a)), a.tag === m.zOffset && (l = z(s, a))) : a.root === m.perFrame && (w = Math.max(w, a.item + 1), a.tag === m.columnPosition && (E = !0));
-  f.forEach((a, g) => {
-    a && h[g] && (a.colorSpace = h[g]);
+async function Ut(e) {
+  const t = e.size, r = async (i, g) => new Uint8Array(await e.slice(i, i + g).arrayBuffer()), { b: s, pixel: o, elements: c } = await xt(r, t), a = /* @__PURE__ */ new Map(), n = [], l = [], f = [];
+  let d, m, h, u = 0, E = !1;
+  for (const i of c)
+    i.depth === 0 ? a.set(i.tag, i) : i.root === w.opticalPathSeq && i.depth === 1 ? (i.tag === w.opticalPathId && (n[i.item] = N(s, i)), i.tag === w.iccProfile && (l[i.item] = { offset: i.offset, length: i.length }), i.tag === w.colorSpace && (f[i.item] = N(s, i))) : i.root === w.shared ? (i.tag === w.spacing && (d = N(s, i)), i.tag === w.opticalPathId && (m = N(s, i)), i.tag === w.zOffset && (h = W(s, i))) : i.root === w.perFrame && (u = Math.max(u, i.item + 1), i.tag === w.columnPosition && (E = !0));
+  l.forEach((i, g) => {
+    i && f[g] && (i.colorSpace = f[g]);
   });
-  const y = (a) => {
-    const g = c.get(a);
+  const y = (i) => {
+    const g = a.get(i);
     return g ? N(s, g) : "";
-  }, S = (a, g, R, j) => {
-    const ct = c.get(a), k = ct ? z(s, ct) : g;
-    if (!Number.isInteger(k) || k < R || k > j)
-      throw new x("malformed", `tag ${a.toString(16)} is ${k}`);
-    return k;
-  }, U = S(m.columns, 0, 0, 65535), I = S(m.rows, 0, 0, 65535);
-  if (!U || !I) throw new x("not-tiled", "no Rows/Columns");
-  const b = S(m.frames, 1, 1, Math.floor((t - n) / 8)), D = S(m.totalColumns, U, 1, 4294967295), $ = S(m.totalRows, I, 1, 4294967295), O = Math.ceil(D / U), M = Math.ceil($ / I), P = O * M;
-  if (P > Q)
-    throw new x("malformed", `${P} tiles in one level (over ${Q})`);
-  const C = S(m.focalPlanes, 1, 1, 65535), nt = S(m.concatOffset, 0, 0, 4294967295), ot = y(m.organization), X = ot === "TILED_SPARSE", G = ot === "TILED_FULL" || !X && !E;
+  }, S = (i, g, R, j) => {
+    const it = a.get(i), B = it ? W(s, it) : g;
+    if (!Number.isInteger(B) || B < R || B > j)
+      throw new P("malformed", `tag ${i.toString(16)} is ${B}`);
+    return B;
+  }, U = S(w.columns, 0, 0, 65535), I = S(w.rows, 0, 0, 65535);
+  if (!U || !I) throw new P("not-tiled", "no Rows/Columns");
+  const x = S(w.frames, 1, 1, Math.floor((t - o) / 8)), D = S(w.totalColumns, U, 1, 4294967295), $ = S(w.totalRows, I, 1, 4294967295), O = Math.ceil(D / U), M = Math.ceil($ / I), b = O * M;
+  if (b > K)
+    throw new P("malformed", `${b} tiles in one level (over ${K})`);
+  const C = S(w.focalPlanes, 1, 1, 65535), et = S(w.concatOffset, 0, 0, 4294967295), nt = y(w.organization), X = nt === "TILED_SPARSE", G = nt === "TILED_FULL" || !X && !E;
   if (G) {
-    const a = S(m.opticalPaths, 1, 1, 65535);
-    if (nt + b > P * C * a)
-      throw new x(
+    const i = S(w.opticalPaths, 1, 1, 65535);
+    if (et + x > b * C * i)
+      throw new P(
         "malformed",
-        `frames past ${P} tiles x ${C} planes x ${a} paths`
+        `frames past ${b} tiles x ${C} planes x ${i} paths`
       );
   }
   const L = {
     instance: {
-      id: y(m.sop),
-      file: et(e),
+      id: y(w.sop),
+      file: tt(e),
       size: t,
       version: String(e.lastModified),
-      transferSyntax: y(m.transferSyntax),
-      photometric: y(m.photometric),
-      bitsStored: S(m.bitsStored, 8, 1, 32)
+      transferSyntax: y(w.transferSyntax),
+      photometric: y(w.photometric),
+      bitsStored: S(w.bitsStored, 8, 1, 32)
     },
-    study: y(m.study),
-    series: y(m.series),
-    frameOfReference: y(m.frameOfReference),
-    container: y(m.container) || void 0,
-    volume: y(m.imageType).includes("VOLUME"),
+    study: y(w.study),
+    series: y(w.series),
+    frameOfReference: y(w.frameOfReference),
+    container: y(w.container) || void 0,
+    volume: y(w.imageType).includes("VOLUME"),
     totalColumns: D,
     totalRows: $,
     tileWidth: U,
     tileHeight: I,
     columns: O,
     rows: M,
-    frameCount: b,
+    frameCount: x,
     sparse: X,
-    concatNumber: S(m.concatNumber, 0, 0, 65535),
-    pathIds: o,
-    icc: f,
-    column: new Int32Array(b),
-    row: new Int32Array(b),
-    path: new Uint32Array(b),
-    z: new Float64Array(b),
+    concatNumber: S(w.concatNumber, 0, 0, 65535),
+    pathIds: n,
+    icc: l,
+    column: new Int32Array(x),
+    row: new Int32Array(x),
+    path: new Uint32Array(x),
+    z: new Float64Array(x),
     zStated: !1,
     planes: [],
-    offset: new Float64Array(b),
-    length: new Uint32Array(b)
+    offset: new Float64Array(x),
+    length: new Uint32Array(x)
   };
-  if (p) {
-    const [a, g] = p.split("\\").map(Number);
-    L.pixelSpacingMM = [g, a];
+  if (d) {
+    const [i, g] = d.split("\\").map(Number);
+    L.pixelSpacingMM = [g, i];
   }
-  const { column: Z, row: Y, path: F, z: B } = L;
-  if (X && !w)
-    throw new x("malformed", "TILED_SPARSE without per-frame positions");
-  if (w && w !== b)
-    throw new x(
+  const { column: Z, row: Y, path: F, z: _ } = L;
+  if (X && !u)
+    throw new P("malformed", "TILED_SPARSE without per-frame positions");
+  if (u && u !== x)
+    throw new P(
       "malformed",
-      `${w} per-frame items for ${b} frames`
+      `${u} per-frame items for ${x} frames`
     );
   if (!G)
     Z.fill(-1), Y.fill(-1);
   else
-    for (let a = 0; a < b; a++) {
-      const g = nt + a, R = g % P;
-      Z[a] = R % O, Y[a] = Math.floor(R / O), B[a] = Math.floor(g / P) % C, F[a] = Math.floor(g / (P * C));
+    for (let i = 0; i < x; i++) {
+      const g = et + i, R = g % b;
+      Z[i] = R % O, Y[i] = Math.floor(R / O), _[i] = Math.floor(g / b) % C, F[i] = Math.floor(g / (b * C));
     }
   const V = /* @__PURE__ */ new Map();
-  o.forEach((a, g) => {
-    V.has(a) || V.set(a, g);
+  n.forEach((i, g) => {
+    V.has(i) || V.set(i, g);
   });
-  const st = (a) => {
-    const g = V.get(a);
-    return g !== void 0 ? g : (V.set(a, o.length), o.push(a) - 1);
+  const ot = (i) => {
+    const g = V.get(i);
+    return g !== void 0 ? g : (V.set(i, n.length), n.push(i) - 1);
   };
-  u !== void 0 && F.fill(st(u));
-  const rt = (a, g) => Number.isInteger(a) && a >= 1 && (a - 1) % g === 0 ? (a - 1) / g : -1;
-  let T = 0, at = -1;
-  for (const a of i) {
-    if (a.root !== m.perFrame) continue;
-    const g = a.item;
-    a.tag === m.columnPosition ? Z[g] = rt(z(s, a), U) : a.tag === m.rowPosition ? Y[g] = rt(z(s, a), I) : a.tag === m.zOffset ? (B[g] = z(s, a), g !== at && T++, at = g) : a.tag === m.opticalPathId && (F[g] = st(N(s, a)));
+  m !== void 0 && F.fill(ot(m));
+  const rt = (i, g) => Number.isInteger(i) && i >= 1 && (i - 1) % g === 0 ? (i - 1) / g : -1;
+  let T = 0, st = -1;
+  for (const i of c) {
+    if (i.root !== w.perFrame) continue;
+    const g = i.item;
+    i.tag === w.columnPosition ? Z[g] = rt(W(s, i), U) : i.tag === w.rowPosition ? Y[g] = rt(W(s, i), I) : i.tag === w.zOffset ? (_[g] = W(s, i), g !== st && T++, st = g) : i.tag === w.opticalPathId && (F[g] = ot(N(s, i)));
   }
-  if (T && T !== b)
-    throw new x("malformed", `ZOffset on ${T} of ${b} frames`);
-  const it = !T && l !== void 0 && (!G || C === 1);
-  it && B.fill(l), L.zStated = T > 0 || it;
+  if (T && T !== x)
+    throw new P("malformed", `ZOffset on ${T} of ${x} frames`);
+  const at = !T && h !== void 0 && (!G || C === 1);
+  at && _.fill(h), L.zStated = T > 0 || at;
   const { planes: H } = L;
-  let Mt = 0;
-  for (let a = 0; a < b; a++) {
-    const g = Math.round(B[a] * 1e3) / 1e3;
+  let St = 0;
+  for (let i = 0; i < x; i++) {
+    const g = Math.round(_[i] * 1e3) / 1e3;
     if (!Number.isFinite(g))
-      throw new x("malformed", `frame ${a + 1} has no finite focal plane`);
-    B[a] = g;
-    const R = F[a];
+      throw new P("malformed", `frame ${i + 1} has no finite focal plane`);
+    _[i] = g;
+    const R = F[i];
     H[R] ?? (H[R] = /* @__PURE__ */ new Set());
     const j = H[R];
-    if (!j.has(g) && (j.add(g), ++Mt > mt))
-      throw new x(
+    if (!j.has(g) && (j.add(g), ++St > ht))
+      throw new P(
         "malformed",
-        `over ${mt} (optical path, focal plane) pairs`
+        `over ${ht} (optical path, focal plane) pairs`
       );
   }
-  return await Dt(L, s, n, c, r), L;
+  return await Ot(L, s, o, a, r), L;
 }
-async function Dt(e, t, r, s, n) {
-  const { frameCount: i, offset: c, length: o } = e, { size: f } = e.instance, h = String.fromCharCode(t[r + 4], t[r + 5]);
-  if (h !== "OB" && h !== "OW")
-    throw new x("malformed", `Pixel Data has VR ${h}`);
-  if (v(t, r + 8) !== _)
-    throw new x("uncompressed", "native (uncompressed) pixel data");
-  if (d(A(t, r + 12), A(t, r + 14)) !== m.item)
-    throw new x("malformed", "no Basic Offset Table item");
-  const p = v(t, r + 16), u = r + 20 + p;
-  if (u > f)
-    throw new x("malformed", "the Basic Offset Table runs past the file");
-  const l = async ($) => {
-    const O = await n($, 8);
-    return { tag: d(A(O, 0), A(O, 2)), length: v(O, 4) };
-  }, w = s.get(m.eot), E = s.get(m.eotLengths);
-  if (w && E && w.length >= 8 * i && E.length >= 8 * i) {
-    const $ = new DataView(t.buffer, t.byteOffset + w.offset, w.length), O = new DataView(
+async function Ot(e, t, r, s, o) {
+  const { frameCount: c, offset: a, length: n } = e, { size: l } = e.instance, f = String.fromCharCode(t[r + 4], t[r + 5]);
+  if (f !== "OB" && f !== "OW")
+    throw new P("malformed", `Pixel Data has VR ${f}`);
+  if (v(t, r + 8) !== k)
+    throw new P("uncompressed", "native (uncompressed) pixel data");
+  if (p(A(t, r + 12), A(t, r + 14)) !== w.item)
+    throw new P("malformed", "no Basic Offset Table item");
+  const d = v(t, r + 16), m = r + 20 + d;
+  if (m > l)
+    throw new P("malformed", "the Basic Offset Table runs past the file");
+  const h = async ($) => {
+    const O = await o($, 8);
+    return { tag: p(A(O, 0), A(O, 2)), length: v(O, 4) };
+  }, u = s.get(w.eot), E = s.get(w.eotLengths);
+  if (u && E && u.length >= 8 * c && E.length >= 8 * c) {
+    const $ = new DataView(t.buffer, t.byteOffset + u.offset, u.length), O = new DataView(
       t.buffer,
       t.byteOffset + E.offset,
       E.length
     );
     let M = !0;
-    for (let P = 0; P < i && M; P++) {
-      c[P] = u + Number($.getBigUint64(8 * P, !0)) + 8;
-      const C = Number(O.getBigUint64(8 * P, !0));
-      M = C <= 4294967295 && c[P] + C <= f, o[P] = C;
+    for (let b = 0; b < c && M; b++) {
+      a[b] = m + Number($.getBigUint64(8 * b, !0)) + 8;
+      const C = Number(O.getBigUint64(8 * b, !0));
+      M = C <= 4294967295 && a[b] + C <= l, n[b] = C;
     }
     if (M) return;
-  } else if (p === 4 * i && p > 0) {
-    const $ = await n(r + 20, p);
-    for (let M = 0; M < i; M++) c[M] = u + v($, 4 * M) + 8;
-    let O = v($, 0) === 0 && c[i - 1] <= f;
-    for (let M = 0; M + 1 < i && O; M++) {
-      const P = c[M + 1] - 8 - c[M];
-      O = P >= 0, o[M] = P;
+  } else if (d === 4 * c && d > 0) {
+    const $ = await o(r + 20, d);
+    for (let M = 0; M < c; M++) a[M] = m + v($, 4 * M) + 8;
+    let O = v($, 0) === 0 && a[c - 1] <= l;
+    for (let M = 0; M + 1 < c && O; M++) {
+      const b = a[M + 1] - 8 - a[M];
+      O = b >= 0, n[M] = b;
     }
     if (O) {
-      let M = c[i - 1] - 8;
-      for (; M + 8 <= f; ) {
-        const P = await l(M);
-        if (P.tag !== m.item || M + 8 + P.length > f) break;
-        M += 8 + P.length;
+      let M = a[c - 1] - 8;
+      for (; M + 8 <= l; ) {
+        const b = await h(M);
+        if (b.tag !== w.item || M + 8 + b.length > l) break;
+        M += 8 + b.length;
       }
-      if (M > c[i - 1] - 8) {
-        o[i - 1] = M - c[i - 1];
+      if (M > a[c - 1] - 8) {
+        n[c - 1] = M - a[c - 1];
         return;
       }
     }
   }
   let y = new Uint8Array(0), S = 0, U = 0;
-  const I = async ($) => (($ < S || $ + 12 > S + y.length) && (S = $, y = await n($, Math.min(U < 4096 ? 65536 : 12, f - $))), y.subarray($ - S, $ - S + 12));
-  let b = u, D = -1;
+  const I = async ($) => (($ < S || $ + 12 > S + y.length) && (S = $, y = await o($, Math.min(U < 4096 ? 65536 : 12, l - $))), y.subarray($ - S, $ - S + 12));
+  let x = m, D = -1;
   for (; ; ) {
-    const $ = await I(b), O = d(A($, 0), A($, 2));
-    if (O === m.sequenceEnd) break;
-    if (O !== m.item)
-      throw new x("malformed", `no fragment item at byte ${b}`);
+    const $ = await I(x), O = p(A($, 0), A($, 2));
+    if (O === w.sequenceEnd) break;
+    if (O !== w.item)
+      throw new P("malformed", `no fragment item at byte ${x}`);
     const M = v($, 4);
-    if (U = M, b + 8 + M > f)
-      throw new x(
+    if (U = M, x + 8 + M > l)
+      throw new P(
         "malformed",
-        `fragment past the end of the file at byte ${b}`
+        `fragment past the end of the file at byte ${x}`
       );
     if (($[8] === 255 && $[9] === 216 || // JPEG and JPEG-LS SOI
     $[8] === 255 && $[9] === 79 && $[10] === 255 && $[11] === 81 || // J2K start-of-codestream + image-size markers
-    $[8] === 0 && $[9] === 0 && $[10] === 0 && $[11] === 12) && D + 1 < i && (c[++D] = b + 8), D < 0)
-      throw new x(
+    $[8] === 0 && $[9] === 0 && $[10] === 0 && $[11] === 12) && D + 1 < c && (a[++D] = x + 8), D < 0)
+      throw new P(
         "malformed",
         "the first fragment does not start a codestream"
       );
-    o[D] = b + 8 + M - c[D], b += 8 + M;
+    n[D] = x + 8 + M - a[D], x += 8 + M;
   }
-  if (D + 1 !== i)
-    throw new x("malformed", `${D + 1} codestreams for ${i} frames`);
+  if (D + 1 !== c)
+    throw new P("malformed", `${D + 1} codestreams for ${c} frames`);
 }
-async function _t(e) {
+async function Lt(e) {
   const t = [], r = [];
   for (const s of e)
     try {
-      t.push(await At(s));
-    } catch (n) {
+      t.push(await Ut(s));
+    } catch (o) {
       r.push({
-        file: et(s),
-        reason: n instanceof x ? n.reason : "malformed",
-        message: n instanceof Error ? n.message : String(n)
+        file: tt(s),
+        reason: o instanceof P ? o.reason : "malformed",
+        message: o instanceof Error ? o.message : String(o)
       });
     }
   return {
     version: 1,
     producer: "nv-ext-tile/indexDicomWsi",
-    slides: Ct(t, r),
+    slides: Dt(t, r),
     skipped: r
   };
 }
-const pt = (e, t) => e.pathIds[t] ?? String(t), tt = (e, t) => [
+const wt = (e, t) => e.pathIds[t] ?? String(t), Q = (e, t) => [
   e.study,
   e.series,
   e.frameOfReference,
   e.container ?? "",
-  pt(e, t)
+  wt(e, t)
 ].join("|");
-function It(e) {
-  const t = e.filter((n) => n.volume && n.zStated), r = /* @__PURE__ */ new Map();
-  for (const n of t)
-    n.planes.forEach((i, c) => {
-      const o = tt(n, c), f = r.get(o) ?? /* @__PURE__ */ new Set();
-      for (const h of i) f.add(h);
-      r.set(o, f);
+function At(e) {
+  const t = e.filter((o) => o.volume && o.zStated), r = /* @__PURE__ */ new Map();
+  for (const o of t)
+    o.planes.forEach((c, a) => {
+      const n = Q(o, a), l = r.get(n) ?? /* @__PURE__ */ new Set();
+      for (const f of c) l.add(f);
+      r.set(n, l);
     });
   const s = new Map(
-    [...r].map(([n, i]) => [
-      n,
-      new Map([...i].sort((c, o) => c - o).map((c, o) => [c, o]))
+    [...r].map(([o, c]) => [
+      o,
+      new Map([...c].sort((a, n) => a - n).map((a, n) => [a, n]))
     ])
   );
-  for (const n of t) {
-    const i = n.planes.map(
-      (f, h) => s.get(tt(n, h))
-    ), { z: c, path: o } = n;
-    for (let f = 0; f < n.frameCount; f++) {
-      const h = i[o[f]];
-      c[f] = h.get(c[f]);
+  for (const o of t) {
+    const c = o.planes.map(
+      (l, f) => s.get(Q(o, f))
+    ), { z: a, path: n } = o;
+    for (let l = 0; l < o.frameCount; l++) {
+      const f = c[n[l]];
+      a[l] = f.get(a[l]);
     }
   }
 }
-function Ct(e, t) {
-  It(e);
+function Dt(e, t) {
+  At(e);
   const r = /* @__PURE__ */ new Map();
-  for (const n of e) {
-    if (!n.volume) continue;
-    const i = [];
-    for (let c = 0; c < n.frameCount; c++) {
-      const o = n.path[c];
-      i[o] ?? (i[o] = /* @__PURE__ */ new Map());
-      const f = i[o], h = n.z[c], p = f.get(h);
-      p ? p.push(c) : f.set(h, [c]);
+  for (const o of e) {
+    if (!o.volume) continue;
+    const c = [];
+    for (let a = 0; a < o.frameCount; a++) {
+      const n = o.path[a];
+      c[n] ?? (c[n] = /* @__PURE__ */ new Map());
+      const l = c[n], f = o.z[a], d = l.get(f);
+      d ? d.push(a) : l.set(f, [a]);
     }
-    i.forEach((c, o) => {
-      const f = pt(n, o), h = tt(n, o);
-      for (const [p, u] of c) {
-        const l = `${h}|${p}`;
-        let w = r.get(l);
-        if (!w) {
-          const { study: E, series: y, frameOfReference: S, container: U } = n;
-          w = {
+    c.forEach((a, n) => {
+      const l = wt(o, n), f = Q(o, n);
+      for (const [d, m] of a) {
+        const h = `${f}|${d}`;
+        let u = r.get(h);
+        if (!u) {
+          const { study: E, series: y, frameOfReference: S, container: U } = o;
+          u = {
             slide: {
               study: E,
               series: y,
               frameOfReference: S,
               container: U,
-              opticalPath: f,
-              focalPlane: p,
+              opticalPath: l,
+              focalPlane: d,
               instances: [],
               levels: []
             },
             own: []
-          }, r.set(l, w);
+          }, r.set(h, u);
         }
-        w.own.push({ info: n, pathIndex: o, frames: u });
+        u.own.push({ info: o, pathIndex: n, frames: m });
       }
     });
   }
   const s = /* @__PURE__ */ new Set();
-  return [...r.values()].map(({ slide: n, own: i }) => {
-    i.sort(
-      (u, l) => l.info.totalColumns * l.info.totalRows - u.info.totalColumns * u.info.totalRows || u.info.concatNumber - l.info.concatNumber
+  return [...r.values()].map(({ slide: o, own: c }) => {
+    c.sort(
+      (m, h) => h.info.totalColumns * h.info.totalRows - m.info.totalColumns * m.info.totalRows || m.info.concatNumber - h.info.concatNumber
     );
-    const c = /* @__PURE__ */ new Map();
-    let o = 0;
-    const f = i.filter(({ info: u }) => {
-      const l = `${u.totalColumns}x${u.totalRows}`;
-      let w = c.get(l);
-      return w === void 0 && (o += u.columns * u.rows, w = o <= ht, c.set(l, w)), !w && !s.has(u.instance.file) && (s.add(u.instance.file), t.push({
-        file: u.instance.file,
+    const a = /* @__PURE__ */ new Map();
+    let n = 0;
+    const l = c.filter(({ info: m }) => {
+      const h = `${m.totalColumns}x${m.totalRows}`;
+      let u = a.get(h);
+      return u === void 0 && (n += m.columns * m.rows, u = n <= lt, a.set(h, u)), !u && !s.has(m.instance.file) && (s.add(m.instance.file), t.push({
+        file: m.instance.file,
         reason: "malformed",
-        message: `level ${l} takes its slide past ${ht} tiles`
-      })), w;
+        message: `level ${h} takes its slide past ${lt} tiles`
+      })), u;
     });
-    n.instances = f.map((u) => u.info.instance);
-    const h = /* @__PURE__ */ new Map();
-    f.forEach(({ info: u }, l) => {
-      const w = `${u.totalColumns}x${u.totalRows}`, E = h.get(w);
-      E ? E.push(l) : h.set(w, [l]);
+    o.instances = l.map((m) => m.info.instance);
+    const f = /* @__PURE__ */ new Map();
+    l.forEach(({ info: m }, h) => {
+      const u = `${m.totalColumns}x${m.totalRows}`, E = f.get(u);
+      E ? E.push(h) : f.set(u, [h]);
     });
-    for (const u of h.values()) n.levels.push(Rt(u, f));
-    const p = f[0];
-    return n.pixelSpacingMM = p.info.pixelSpacingMM, n.iccProfile = p.info.icc[p.pathIndex], n;
+    for (const m of f.values()) o.levels.push(It(m, l));
+    const d = l[0];
+    return o.pixelSpacingMM = d.info.pixelSpacingMM, o.iccProfile = d.info.icc[d.pathIndex], o;
   });
 }
-function Rt(e, t) {
-  const r = t[e[0]].info, { columns: s, rows: n } = r, i = e.reduce((l, w) => l + t[w].frames.length, 0), c = {
-    instance: new Uint32Array(i),
-    frame: new Uint32Array(i),
-    offset: new Float64Array(i),
-    length: new Uint32Array(i),
-    tile: new Int32Array(i)
+function It(e, t) {
+  const r = t[e[0]].info, { columns: s, rows: o } = r, c = e.reduce((h, u) => h + t[u].frames.length, 0), a = {
+    instance: new Uint32Array(c),
+    frame: new Uint32Array(c),
+    offset: new Float64Array(c),
+    length: new Uint32Array(c),
+    tile: new Int32Array(c)
   };
-  let o = 0;
-  for (const l of e) {
-    const w = t[l], { info: E } = w;
-    for (const y of w.frames) {
+  let n = 0;
+  for (const h of e) {
+    const u = t[h], { info: E } = u;
+    for (const y of u.frames) {
       const S = E.column[y], U = E.row[y];
-      c.instance[o] = l, c.frame[o] = y + 1, c.offset[o] = E.offset[y], c.length[o] = E.length[y], c.tile[o] = S < 0 || U < 0 || S >= s || U >= n ? -1 : U * s + S, o++;
+      a.instance[n] = h, a.frame[n] = y + 1, a.offset[n] = E.offset[y], a.length[n] = E.length[y], a.tile[n] = S < 0 || U < 0 || S >= s || U >= o ? -1 : U * s + S, n++;
     }
   }
-  const f = c.tile.slice().sort();
-  let h = 0, p = -1;
-  for (const l of f)
-    l > p && (h++, p = l);
-  const u = s * n - h;
+  const l = a.tile.slice().sort();
+  let f = 0, d = -1;
+  for (const h of l)
+    h > d && (f++, d = h);
+  const m = s * o - f;
   return {
     width: r.totalColumns,
     height: r.totalRows,
     tileWidth: r.tileWidth,
     tileHeight: r.tileHeight,
     columns: s,
-    rows: n,
+    rows: o,
     instances: e,
-    frames: c,
-    duplicates: i - h,
-    holes: u,
-    sparse: u > 0 || e.some((l) => t[l].info.sparse)
+    frames: a,
+    duplicates: c - f,
+    holes: m,
+    sparse: m > 0 || e.some((h) => t[h].info.sparse)
   };
 }
-function gt(e) {
+function dt(e) {
   const t = new Int32Array(e.columns * e.rows).fill(-1), { tile: r } = e.frames;
   for (let s = r.length - 1; s >= 0; s--) {
-    const n = r[s];
-    n >= 0 && (t[n] = s);
+    const o = r[s];
+    o >= 0 && (t[o] = s);
   }
   return t;
 }
-const Nt = {
+const Ct = {
   "1.2.840.10008.1.2.4.50": "image/jpeg",
   // JPEG Baseline (Process 1)
   "1.2.840.10008.1.2.4.51": "image/jpeg",
@@ -531,34 +565,34 @@ const Nt = {
   "1.2.840.10008.1.2.4.91": "image/jp2"
   // JPEG 2000
 };
-function yt(e, t) {
-  const r = new Map(t.map((s) => [et(s), s]));
+function pt(e, t) {
+  const r = new Map(t.map((s) => [tt(s), s]));
   return e.instances.map((s) => {
-    const n = r.get(s.file);
-    if (!n) throw new Error(`${s.file} is not among the files`);
-    if (n.size !== s.size || String(n.lastModified) !== s.version)
+    const o = r.get(s.file);
+    if (!o) throw new Error(`${s.file} is not among the files`);
+    if (o.size !== s.size || String(o.lastModified) !== s.version)
       throw new Error(`${s.file} changed since it was indexed`);
-    return n;
+    return o;
   });
 }
-function St(e, t) {
+function gt(e, t) {
   const r = new DataView(e.buffer, e.byteOffset, e.byteLength), s = [];
-  for (let n = 0; n < e.length; ) {
-    if (n + 8 > e.length || r.getUint16(n, !0) !== 65534 || r.getUint16(n + 2, !0) !== 57344)
+  for (let o = 0; o < e.length; ) {
+    if (o + 8 > e.length || r.getUint16(o, !0) !== 65534 || r.getUint16(o + 2, !0) !== 57344)
       throw new Error(
-        n === 0 ? `${t} is not where the index says` : `${t}: no fragment item at byte ${n}`
+        o === 0 ? `${t} is not where the index says` : `${t}: no fragment item at byte ${o}`
       );
-    const i = r.getUint32(n + 4, !0);
-    if (n + 8 + i > e.length)
+    const c = r.getUint32(o + 4, !0);
+    if (o + 8 + c > e.length)
       throw new Error(`${t}: a fragment runs past its span`);
-    s.push({ offset: n + 8, length: i }), n += 8 + i;
+    s.push({ offset: o + 8, length: c }), o += 8 + c;
   }
   if (!s.length) throw new Error(`${t}: an empty span`);
   return s;
 }
-class Bt {
+class Tt {
   constructor(t, r) {
-    this.slide = t, this.host = null, this.files = yt(t, r), this.maps = t.levels.map(gt), this.manifest = $t(t, this.maps);
+    this.slide = t, this.host = null, this.files = pt(t, r), this.maps = t.levels.map(dt), this.manifest = yt(t, this.maps);
   }
   bind(t) {
     this.host = t;
@@ -567,144 +601,144 @@ class Bt {
   async fetchIccProfile(t) {
     const r = this.slide.iccProfile, s = this.slide.levels[0];
     if (!r || !s) return null;
-    const n = this.files[s.instances[0]], i = new Uint8Array(
-      await n.slice(r.offset, r.offset + r.length).arrayBuffer()
+    const o = this.files[s.instances[0]], c = new Uint8Array(
+      await o.slice(r.offset, r.offset + r.length).arrayBuffer()
     );
-    return t == null || t.throwIfAborted(), i;
+    return t == null || t.throwIfAborted(), c;
   }
-  async fetchTileBytes(t, r, s, n) {
+  async fetchTileBytes(t, r, s, o) {
     var y;
-    const { frames: i } = this.slide.levels[t.index], o = this.maps[t.index][r.y * t.columns + r.x];
-    if (!(o >= 0)) throw new Error(`no frame for tile ${r.x},${r.y}`);
-    const f = this.files[i.instance[o]], h = i.offset[o], p = i.length[o], u = new Uint8Array(
-      await f.slice(h - 8, h + p).arrayBuffer()
+    const { frames: c } = this.slide.levels[t.index], n = this.maps[t.index][r.y * t.columns + r.x];
+    if (!(n >= 0)) throw new Error(`no frame for tile ${r.x},${r.y}`);
+    const l = this.files[c.instance[n]], f = c.offset[n], d = c.length[n], m = new Uint8Array(
+      await l.slice(f - 8, f + d).arrayBuffer()
     );
-    n == null || n.throwIfAborted(), (y = this.host) == null || y.addWireBytes(u.byteLength);
-    const l = St(u, `${f.name} frame ${i.frame[o]}`);
-    if (l.length === 1) return u.subarray(8);
-    const w = new Uint8Array(l.reduce((S, U) => S + U.length, 0));
+    o == null || o.throwIfAborted(), (y = this.host) == null || y.addWireBytes(m.byteLength);
+    const h = gt(m, `${l.name} frame ${c.frame[n]}`);
+    if (h.length === 1) return m.subarray(8);
+    const u = new Uint8Array(h.reduce((S, U) => S + U.length, 0));
     let E = 0;
-    for (const S of l)
-      w.set(u.subarray(S.offset, S.offset + S.length), E), E += S.length;
-    return w;
+    for (const S of h)
+      u.set(m.subarray(S.offset, S.offset + S.length), E), E += S.length;
+    return u;
   }
 }
-function $t(e, t, {
+function yt(e, t, {
   format: r = "dicom-wsi-index-v1",
-  fileUrl: s = (n) => n.file
+  fileUrl: s = (o) => o.file
 } = {}) {
-  const n = e.levels[0];
-  if (!n) throw new Error("the slide has no levels");
-  const i = e.instances[n.instances[0]], c = e.levels.map((o, f) => {
-    const h = e.instances[o.instances[0]], p = Nt[h.transferSyntax];
-    if (!p)
+  const o = e.levels[0];
+  if (!o) throw new Error("the slide has no levels");
+  const c = e.instances[o.instances[0]], a = e.levels.map((n, l) => {
+    const f = e.instances[n.instances[0]], d = Ct[f.transferSyntax];
+    if (!d)
       throw new Error(
-        `transfer syntax ${h.transferSyntax} cannot be decoded (JPEG, JPEG 2000 and JPEG-LS are supported)`
+        `transfer syntax ${f.transferSyntax} cannot be decoded (JPEG, JPEG 2000 and JPEG-LS are supported)`
       );
-    const u = Array.from(
-      t[f],
-      (l, w) => {
-        if (l < 0) return null;
-        const E = w % o.columns, y = Math.floor(w / o.columns);
+    const m = Array.from(
+      t[l],
+      (h, u) => {
+        if (h < 0) return null;
+        const E = u % n.columns, y = Math.floor(u / n.columns);
         return {
           x: E,
           y,
-          width: Math.min(o.tileWidth, o.width - E * o.tileWidth),
+          width: Math.min(n.tileWidth, n.width - E * n.tileWidth),
           height: Math.min(
-            o.tileHeight,
-            o.height - y * o.tileHeight
+            n.tileHeight,
+            n.height - y * n.tileHeight
           ),
-          frame: o.frames.frame[l]
+          frame: n.frames.frame[h]
         };
       }
     );
     return {
-      index: f,
-      width: o.width,
-      height: o.height,
-      downsample: n.width / o.width,
-      tileWidth: o.tileWidth,
-      tileHeight: o.tileHeight,
-      columns: o.columns,
-      rows: o.rows,
-      codec: p,
-      transferSyntaxUid: h.transferSyntax,
-      photometric: h.photometric,
-      bitsStored: h.bitsStored,
-      frames: o.frames.offset.length,
+      index: l,
+      width: n.width,
+      height: n.height,
+      downsample: o.width / n.width,
+      tileWidth: n.tileWidth,
+      tileHeight: n.tileHeight,
+      columns: n.columns,
+      rows: n.rows,
+      codec: d,
+      transferSyntaxUid: f.transferSyntax,
+      photometric: f.photometric,
+      bitsStored: f.bitsStored,
+      frames: n.frames.offset.length,
       // The index made one slide per optical path and focal plane.
       opticalPaths: 1,
       focalPlanes: 1,
-      ...o.sparse ? { sparse: !0 } : {},
-      tiles: u
+      ...n.sparse ? { sparse: !0 } : {},
+      tiles: m
     };
   });
   return {
     id: `${e.series}/${e.opticalPath}/${e.focalPlane}`,
     name: e.container ?? e.series,
     format: r,
-    width: n.width,
-    height: n.height,
+    width: o.width,
+    height: o.height,
     // Row 0 at the top, as OpenSlide and the TIFF/DZI sources show a slide.
     displayYAxis: "down",
-    tileSize: n.tileWidth,
+    tileSize: o.tileWidth,
     dtype: "uint8",
     channels: "encoded-rgb",
     ...e.pixelSpacingMM ? { pixelSpacingMM: e.pixelSpacingMM } : {},
-    ...e.iccProfile ? { iccProfile: { url: s(i), ...e.iccProfile } } : {},
-    levels: c
+    ...e.iccProfile ? { iccProfile: { url: s(c), ...e.iccProfile } } : {},
+    levels: a
   };
 }
 async function kt(e, t, r) {
-  const s = yt(e, t), n = e.levels.map(gt), i = $t(e, n, {
+  const s = pt(e, t), o = e.levels.map(dt), c = yt(e, o, {
     format: "dicom-wsi-range-v1",
     fileUrl: r
   });
-  for (const [c, o] of i.levels.entries()) {
-    const f = e.levels[c], { frames: h } = f, p = f.instances.length > 1;
-    p || (o.fileUrl = r(
-      e.instances[f.instances[0]]
+  for (const [a, n] of c.levels.entries()) {
+    const l = e.levels[a], { frames: f } = l, d = l.instances.length > 1;
+    d || (n.fileUrl = r(
+      e.instances[l.instances[0]]
     ));
-    const u = [];
-    for (const [l, w] of n[c].entries()) {
-      if (w < 0) continue;
-      const E = o.tiles[l], y = h.instance[w], S = await vt(
+    const m = [];
+    for (const [h, u] of o[a].entries()) {
+      if (u < 0) continue;
+      const E = n.tiles[h], y = f.instance[u], S = await Rt(
         s[y],
-        h.offset[w],
-        h.length[w]
+        f.offset[u],
+        f.length[u]
       );
-      u.push({
+      m.push({
         ...E,
         ...S,
-        ...p ? { fileUrl: r(e.instances[y]) } : {}
+        ...d ? { fileUrl: r(e.instances[y]) } : {}
       });
     }
-    o.tiles = u;
+    n.tiles = m;
   }
-  return i;
+  return c;
 }
-async function vt(e, t, r) {
+async function Rt(e, t, r) {
   const s = new Uint8Array(
     await e.slice(t - 8, t).arrayBuffer()
-  ), n = `${e.name} at byte ${t - 8}`, i = new DataView(s.buffer);
-  if (i.getUint32(4, !0) === r) {
-    if (i.getUint32(0, !0) !== 3758161918)
-      throw new Error(`${n}: no item where the index says`);
+  ), o = `${e.name} at byte ${t - 8}`, c = new DataView(s.buffer);
+  if (c.getUint32(4, !0) === r) {
+    if (c.getUint32(0, !0) !== 3758161918)
+      throw new Error(`${o}: no item where the index says`);
     return { offset: t, length: r };
   }
-  const c = new Uint8Array(
+  const a = new Uint8Array(
     await e.slice(t - 8, t + r).arrayBuffer()
   );
   return {
-    fragments: St(c, n).map((f) => ({
-      offset: t - 8 + f.offset,
-      length: f.length
+    fragments: gt(a, o).map((l) => ({
+      offset: t - 8 + l.offset,
+      length: l.length
     }))
   };
 }
 export {
-  Bt as DicomWsiSource,
-  _t as indexDicomWsi,
+  Tt as DicomWsiSource,
+  Lt as indexDicomWsi,
   kt as manifestFromIndex,
-  Tt as registerDcm2niixDecoders
+  vt as registerDcm2niixDecoders
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niivue/nv-ext-tile",
-  "version": "1.0.0-rc.7",
+  "version": "1.0.0-rc.8",
   "type": "module",
   "description": "Tiled image formats for NiiVue's NVSlide: pyramidal TIFF/OME-TIFF/SVS by HTTP Range (/tiff) and DICOM-WSI folders and hosted manifests (/dicom)",
   "exports": {
@@ -19,7 +19,7 @@
   "comment:niivue-peer": "workspace:^, not workspace:* (which bun publish pins to the exact rc): published as ^<core version at publish>, so one release accepts later niivue rcs and 1.x, and the floor never predates an API this package uses.",
   "peerDependencies": {
     "@niivue/dcm2niix": "^1.4.20261105-rc.3",
-    "@niivue/niivue": "^1.0.0-rc.116"
+    "@niivue/niivue": "^1.0.0-rc.117"
   },
   "peerDependenciesMeta": {
     "@niivue/dcm2niix": {
@@ -31,7 +31,7 @@
   },
   "devDependencies": {
     "@niivue/dcm2niix": "^1.4.20261105-rc.3",
-    "@niivue/niivue": "1.0.0-rc.116",
+    "@niivue/niivue": "1.0.0-rc.117",
     "@types/bun": "^1.3.12",
     "typescript": "~5.8.3",
     "vite": "^6.3.2",