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

package/fesm2022/region-source.worker.js

@@ -0,0 +1,1067 @@
+// src/lib/geometry/reconstruct.ts
+import { pointInRing, ringArea, smoothMesh, surfaceNets } from "napari-js/geometry";
+
+// src/lib/geometry/loft.ts
+var MAX_POINTS = 2048;
+var MATCH_POINTS = 32;
+function loftLines(slices, step = 1) {
+  const stack = slices.map((s) => ({ z: s.z, lines: s.lines.filter((l) => l.length >= 4) })).filter((s) => s.lines.length).sort((a, b) => a.z - b.z);
+  if (stack.length < 2)
+    return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+  let longest = 0;
+  for (const s of stack)
+    for (const l of s.lines)
+      longest = Math.max(longest, lineLength(l));
+  const n = Math.min(MAX_POINTS, Math.max(2, Math.ceil(longest / Math.max(step, 1e-6)) + 1));
+  const rows = [];
+  const verts = [];
+  for (const s of stack) {
+    rows.push(
+      s.lines.map((l) => {
+        const first = verts.length / 3;
+        const pts = resample(l, n);
+        for (let i = 0; i < n; i++)
+          verts.push(pts[2 * i], pts[2 * i + 1], s.z);
+        return { first, probe: resample(l, MATCH_POINTS), box: lineBox(l) };
+      })
+    );
+  }
+  const faces = [];
+  for (let k = 0; k + 1 < rows.length; k++) {
+    for (const { a, b, reversed } of matchLines(rows[k], rows[k + 1])) {
+      const at = (i) => b.first + (reversed ? n - 1 - i : i);
+      for (let i = 0; i + 1 < n; i++) {
+        const a0 = a.first + i, a1 = a0 + 1, b0 = at(i), b1 = at(i + 1);
+        faces.push(a0, b0, a1, a1, b0, b1);
+      }
+    }
+  }
+  if (!faces.length)
+    return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+  return { vertices: Float32Array.from(verts), faces: Uint32Array.from(faces) };
+}
+function matchLines(as, bs) {
+  const pairs = [];
+  as.forEach(
+    (a, i) => bs.forEach((b, j) => {
+      if (!boxesOverlap(a.box, b.box))
+        return;
+      const forward = meanDistance(a.probe, b.probe, false);
+      const backward = meanDistance(a.probe, b.probe, true);
+      pairs.push({ a: i, b: j, cost: Math.min(forward, backward), reversed: backward < forward });
+    })
+  );
+  pairs.sort((p, q) => p.cost - q.cost);
+  const usedA = /* @__PURE__ */ new Set();
+  const usedB = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of pairs) {
+    if (usedA.has(p.a) || usedB.has(p.b))
+      continue;
+    usedA.add(p.a);
+    usedB.add(p.b);
+    out.push({ a: as[p.a], b: bs[p.b], reversed: p.reversed });
+  }
+  return out;
+}
+function meanDistance(a, b, reversed) {
+  const n = a.length >> 1;
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    const j = reversed ? n - 1 - i : i;
+    sum += Math.hypot(a[2 * i] - b[2 * j], a[2 * i + 1] - b[2 * j + 1]);
+  }
+  return sum / n;
+}
+function resample(line, n) {
+  const m = line.length >> 1;
+  const cumulative = new Float64Array(m);
+  for (let i = 1; i < m; i++) {
+    cumulative[i] = cumulative[i - 1] + Math.hypot(line[2 * i] - line[2 * i - 2], line[2 * i + 1] - line[2 * i - 1]);
+  }
+  const total = cumulative[m - 1];
+  const out = new Float64Array(2 * n);
+  let seg = 1;
+  for (let i = 0; i < n; i++) {
+    const d = n === 1 ? 0 : total * i / (n - 1);
+    while (seg < m - 1 && cumulative[seg] < d)
+      seg++;
+    const span = cumulative[seg] - cumulative[seg - 1];
+    const t = span > 0 ? Math.min(1, Math.max(0, (d - cumulative[seg - 1]) / span)) : 0;
+    out[2 * i] = line[2 * seg - 2] + t * (line[2 * seg] - line[2 * seg - 2]);
+    out[2 * i + 1] = line[2 * seg - 1] + t * (line[2 * seg + 1] - line[2 * seg - 1]);
+  }
+  return out;
+}
+function lineLength(line) {
+  let len = 0;
+  for (let i = 2; i + 1 < line.length; i += 2)
+    len += Math.hypot(line[i] - line[i - 2], line[i + 1] - line[i - 1]);
+  return len;
+}
+function lineBox(line) {
+  const box = [Infinity, Infinity, -Infinity, -Infinity];
+  for (let i = 0; i + 1 < line.length; i += 2) {
+    box[0] = Math.min(box[0], line[i]);
+    box[1] = Math.min(box[1], line[i + 1]);
+    box[2] = Math.max(box[2], line[i]);
+    box[3] = Math.max(box[3], line[i + 1]);
+  }
+  return box;
+}
+function boxesOverlap(a, b) {
+  const ga = 0.1 * Math.max(a[2] - a[0], a[3] - a[1]);
+  const gb = 0.1 * Math.max(b[2] - b[0], b[3] - b[1]);
+  const g = ga + gb;
+  return a[0] - g <= b[2] && b[0] - g <= a[2] && a[1] - g <= b[3] && b[1] - g <= a[3];
+}
+
+// src/lib/geometry/reconstruct.ts
+function reconstruct(slices, opts = {}) {
+  const filled = fill(slices, opts);
+  const lines = slices.filter((s) => s.lines?.length);
+  if (!lines.length)
+    return filled;
+  const sheet = loftLines(
+    lines.map((s) => ({ z: s.z, lines: s.lines ?? [] })),
+    opts.pixelStep ?? 1
+  );
+  return mergeMeshes(filled, sheet);
+}
+function fill(slices, opts) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity, z0 = Infinity, z1 = -Infinity;
+  for (const s of slices) {
+    for (const r of s.rings) {
+      for (let i = 0; i + 1 < r.length; i += 2) {
+        if (r[i] < x0)
+          x0 = r[i];
+        if (r[i] > x1)
+          x1 = r[i];
+        if (r[i + 1] < y0)
+          y0 = r[i + 1];
+        if (r[i + 1] > y1)
+          y1 = r[i + 1];
+      }
+    }
+    if (s.rings.length) {
+      z0 = Math.min(z0, s.z);
+      z1 = Math.max(z1, s.z);
+    }
+  }
+  if (!(x1 > x0) || !(y1 > y0))
+    return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+  const nz = z1 - z0 + 1;
+  const maxVoxels = opts.maxVoxels ?? 32e6;
+  let step = Math.max(opts.pixelStep ?? 1, 1e-6);
+  while (Math.ceil((x1 - x0) / step) * Math.ceil((y1 - y0) / step) * nz > maxVoxels)
+    step *= 1.25;
+  const nx = Math.max(1, Math.ceil((x1 - x0) / step));
+  const ny = Math.max(1, Math.ceil((y1 - y0) / step));
+  const mask = new Uint8Array(nx * ny * nz);
+  for (const s of slices) {
+    for (const rings of featureRings(s.rings, s.ringGroups)) {
+      fillSlice(mask, nx, ny, (s.z - z0) * nx * ny, rings, x0, y0, step);
+    }
+  }
+  const mesh = smoothMesh(surfaceNets(mask, [nx, ny, nz], { origin: [0.5, 0.5, 0.5] }), {
+    iterations: opts.smooth ?? 2
+  });
+  const v = mesh.vertices;
+  for (let i = 0; i < v.length; i += 3) {
+    v[i] = x0 + v[i] * step;
+    v[i + 1] = y0 + v[i + 1] * step;
+    v[i + 2] = z0 + v[i + 2] - 0.5;
+  }
+  return mesh;
+}
+function mergeMeshes(a, b) {
+  if (!b.faces.length)
+    return a;
+  if (!a.faces.length)
+    return b;
+  const vertices = new Float32Array(a.vertices.length + b.vertices.length);
+  vertices.set(a.vertices);
+  vertices.set(b.vertices, a.vertices.length);
+  const faces = new Uint32Array(a.faces.length + b.faces.length);
+  faces.set(a.faces);
+  const offset = a.vertices.length / 3;
+  for (let i = 0; i < b.faces.length; i++)
+    faces[a.faces.length + i] = b.faces[i] + offset;
+  return { vertices, faces };
+}
+function fillSlice(mask, nx, ny, offset, rings, x0, y0, step) {
+  const crossings = [];
+  let top = Infinity, bottom = -Infinity;
+  for (const r of rings) {
+    for (let i = 1; i < r.length; i += 2) {
+      if (r[i] < top)
+        top = r[i];
+      if (r[i] > bottom)
+        bottom = r[i];
+    }
+  }
+  const j0 = Math.max(0, Math.floor((top - y0) / step - 0.5));
+  const j1 = Math.min(ny - 1, Math.ceil((bottom - y0) / step - 0.5));
+  for (let j = j0; j <= j1; j++) {
+    const y = y0 + (j + 0.5) * step;
+    crossings.length = 0;
+    for (const r of rings) {
+      const n = r.length >> 1;
+      for (let i = 0, k = n - 1; i < n; k = i++) {
+        const ya = r[2 * i + 1], yb = r[2 * k + 1];
+        if (ya > y !== yb > y) {
+          const xa = r[2 * i], xb = r[2 * k];
+          crossings.push(xa + (y - ya) * (xb - xa) / (yb - ya));
+        }
+      }
+    }
+    if (crossings.length < 2)
+      continue;
+    crossings.sort((a, b) => a - b);
+    const row = offset + j * nx;
+    for (let c = 0; c + 1 < crossings.length; c += 2) {
+      const from = Math.max(0, Math.ceil((crossings[c] - x0) / step - 0.5));
+      const to = Math.min(nx - 1, Math.floor((crossings[c + 1] - x0) / step - 0.5));
+      for (let i = from; i <= to; i++)
+        mask[row + i] = 1;
+    }
+  }
+}
+function ringsArea(rings) {
+  const boxes = rings.map(ringBox);
+  let area = 0;
+  for (let i = 0; i < rings.length; i++) {
+    const r = rings[i];
+    if (r.length < 6)
+      continue;
+    const x = r[0], y = r[1];
+    let depth = 0;
+    for (let j = 0; j < rings.length; j++) {
+      if (j === i)
+        continue;
+      const b = boxes[j];
+      if (x < b[0] || x > b[2] || y < b[1] || y > b[3])
+        continue;
+      if (pointInRing(x, y, rings[j]))
+        depth++;
+    }
+    area += (depth % 2 ? -1 : 1) * Math.abs(ringArea(r));
+  }
+  return Math.max(0, area);
+}
+function featureRings(rings, groups) {
+  if (!groups || !rings.length)
+    return rings.length ? [rings.slice()] : [];
+  const byGroup = /* @__PURE__ */ new Map();
+  rings.forEach((r, i) => {
+    const g = groups[i] ?? 0;
+    const feature = byGroup.get(g);
+    if (feature)
+      feature.push(r);
+    else
+      byGroup.set(g, [r]);
+  });
+  return [...byGroup.values()];
+}
+function ringBox(r) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (let i = 0; i + 1 < r.length; i += 2) {
+    if (r[i] < x0)
+      x0 = r[i];
+    if (r[i] > x1)
+      x1 = r[i];
+    if (r[i + 1] < y0)
+      y0 = r[i + 1];
+    if (r[i + 1] > y1)
+      y1 = r[i + 1];
+  }
+  return [x0, y0, x1, y1];
+}
+
+// src/lib/contracts/color.ts
+function rgbToHex(rgb) {
+  const h = (n) => clampByte(n).toString(16).padStart(2, "0");
+  return `#${h(rgb[0])}${h(rgb[1])}${h(rgb[2])}`;
+}
+function clampByte(n) {
+  return Math.max(0, Math.min(255, Math.round(n)));
+}
+
+// src/lib/geometry/ring.ts
+function perpDistance(px, py, ax, ay, bx, by) {
+  const dx = bx - ax, dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0)
+    return Math.hypot(px - ax, py - ay);
+  let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function simplifyRing(xs, ys, epsilon) {
+  const n = xs.length;
+  if (n <= 3 || !(epsilon > 0))
+    return { xs: xs.slice(), ys: ys.slice() };
+  const px = [...xs, xs[0]];
+  const py = [...ys, ys[0]];
+  const m = px.length;
+  const keep = new Array(m).fill(false);
+  keep[0] = true;
+  keep[m - 1] = true;
+  const stack = [[0, m - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    let maxD = -1, idx = -1;
+    for (let i = a + 1; i < b; i++) {
+      const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);
+      if (d > maxD) {
+        maxD = d;
+        idx = i;
+      }
+    }
+    if (maxD > epsilon && idx > a) {
+      keep[idx] = true;
+      stack.push([a, idx], [idx, b]);
+    }
+  }
+  const outX = [], outY = [];
+  for (let i = 0; i < m - 1; i++) {
+    if (keep[i]) {
+      outX.push(px[i]);
+      outY.push(py[i]);
+    }
+  }
+  return { xs: outX, ys: outY };
+}
+
+// src/lib/geometry/polylabel.ts
+function polylabel(rings, precision) {
+  const outer = rings[0];
+  if (!outer || outer.length < 6)
+    return null;
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + 1 < outer.length; i += 2) {
+    if (outer[i] < minX)
+      minX = outer[i];
+    if (outer[i] > maxX)
+      maxX = outer[i];
+    if (outer[i + 1] < minY)
+      minY = outer[i + 1];
+    if (outer[i + 1] > maxY)
+      maxY = outer[i + 1];
+  }
+  const width = maxX - minX;
+  const height = maxY - minY;
+  const cellSize = Math.min(width, height);
+  const eps = precision ?? Math.max(0.5, cellSize / 100);
+  if (cellSize <= 0)
+    return { x: minX, y: minY, distance: 0 };
+  const cell = (x, y, h2) => {
+    const d = signedDistance(x, y, rings);
+    return { x, y, h: h2, d, max: d + h2 * Math.SQRT2 };
+  };
+  const queue = new MaxHeap();
+  const h = cellSize / 2;
+  for (let x = minX; x < maxX; x += cellSize) {
+    for (let y = minY; y < maxY; y += cellSize)
+      queue.push(cell(x + h, y + h, h));
+  }
+  let best = cell(minX + width / 2, minY + height / 2, 0);
+  const centroid = areaCentroid(outer);
+  if (centroid) {
+    const c = cell(centroid[0], centroid[1], 0);
+    if (c.d > best.d)
+      best = c;
+  }
+  let guard = 0;
+  while (queue.size && guard++ < 1e4) {
+    const c = queue.pop();
+    if (c.d > best.d)
+      best = c;
+    if (c.max - best.d <= eps)
+      continue;
+    const q = c.h / 2;
+    queue.push(cell(c.x - q, c.y - q, q));
+    queue.push(cell(c.x + q, c.y - q, q));
+    queue.push(cell(c.x - q, c.y + q, q));
+    queue.push(cell(c.x + q, c.y + q, q));
+  }
+  return { x: best.x, y: best.y, distance: Math.max(0, best.d) };
+}
+function signedDistance(x, y, rings) {
+  let inside = false;
+  let min = Infinity;
+  for (const r of rings) {
+    const n = r.length >> 1;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+      const ax = r[2 * i], ay = r[2 * i + 1], bx = r[2 * j], by = r[2 * j + 1];
+      if (ay > y !== by > y && x < (bx - ax) * (y - ay) / (by - ay) + ax)
+        inside = !inside;
+      const d = segmentDistanceSq(x, y, ax, ay, bx, by);
+      if (d < min)
+        min = d;
+    }
+  }
+  return (inside ? 1 : -1) * Math.sqrt(min);
+}
+function segmentDistanceSq(px, py, ax, ay, bx, by) {
+  let x = ax, y = ay;
+  let dx = bx - x, dy = by - y;
+  if (dx !== 0 || dy !== 0) {
+    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+    if (t > 1) {
+      x = bx;
+      y = by;
+    } else if (t > 0) {
+      x += dx * t;
+      y += dy * t;
+    }
+  }
+  dx = px - x;
+  dy = py - y;
+  return dx * dx + dy * dy;
+}
+function areaCentroid(r) {
+  const n = r.length >> 1;
+  let area = 0, cx = 0, cy = 0;
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const f = r[2 * i] * r[2 * j + 1] - r[2 * j] * r[2 * i + 1];
+    cx += (r[2 * i] + r[2 * j]) * f;
+    cy += (r[2 * i + 1] + r[2 * j + 1]) * f;
+    area += f * 3;
+  }
+  return area === 0 ? null : [cx / area, cy / area];
+}
+var MaxHeap = class {
+  constructor() {
+    this.items = [];
+  }
+  get size() {
+    return this.items.length;
+  }
+  push(c) {
+    const a = this.items;
+    a.push(c);
+    let i = a.length - 1;
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (a[p].max >= a[i].max)
+        break;
+      [a[p], a[i]] = [a[i], a[p]];
+      i = p;
+    }
+  }
+  pop() {
+    const a = this.items;
+    const top = a[0];
+    const last = a.pop();
+    if (a.length && last) {
+      a[0] = last;
+      let i = 0;
+      for (; ; ) {
+        const l = 2 * i + 1, r = l + 1;
+        let m = i;
+        if (l < a.length && a[l].max > a[m].max)
+          m = l;
+        if (r < a.length && a[r].max > a[m].max)
+          m = r;
+        if (m === i)
+          break;
+        [a[m], a[i]] = [a[i], a[m]];
+        i = m;
+      }
+    }
+    return top;
+  }
+};
+
+// src/lib/region-source/region-tiles.ts
+var REGION_TILE_SIZE = 512;
+function levelTolerance(level) {
+  return level <= 0 ? 0 : 2 ** (level - 1);
+}
+function levelMinExtent(level) {
+  return level <= 0 ? 0 : 2 ** level;
+}
+function levelTileSize(level, tileSize = REGION_TILE_SIZE) {
+  return tileSize * 2 ** level;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+  const dx = bx - ax, dy = by - ay;
+  const len2 = dx * dx + dy * dy;
+  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / len2));
+  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+function simplifyPolyline(xs, ys, epsilon) {
+  const n = xs.length;
+  if (n <= 2 || !(epsilon > 0))
+    return { xs: xs.slice(), ys: ys.slice() };
+  const keep = new Uint8Array(n);
+  keep[0] = keep[n - 1] = 1;
+  const stack = [[0, n - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    let maxD = -1, idx = -1;
+    for (let i = a + 1; i < b; i++) {
+      const d = segmentDistance(xs[i], ys[i], xs[a], ys[a], xs[b], ys[b]);
+      if (d > maxD) {
+        maxD = d;
+        idx = i;
+      }
+    }
+    if (maxD > epsilon) {
+      keep[idx] = 1;
+      stack.push([a, idx], [idx, b]);
+    }
+  }
+  const ox = [], oy = [];
+  for (let i = 0; i < n; i++) {
+    if (keep[i]) {
+      ox.push(xs[i]);
+      oy.push(ys[i]);
+    }
+  }
+  return { xs: ox, ys: oy };
+}
+function simplifyRings(rings, open, level) {
+  const tol = levelTolerance(level);
+  const minExtent = levelMinExtent(level);
+  const minVertices = open ? 2 : 3;
+  const out = [];
+  for (const ring of rings) {
+    const n = ring.length >> 1;
+    if (n < minVertices)
+      continue;
+    if (tol === 0) {
+      out.push(Float32Array.from(ring));
+      continue;
+    }
+    const xs = new Array(n), ys = new Array(n);
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (let i = 0; i < n; i++) {
+      const x = ring[2 * i], y = ring[2 * i + 1];
+      xs[i] = x;
+      ys[i] = y;
+      if (x < x0)
+        x0 = x;
+      if (x > x1)
+        x1 = x;
+      if (y < y0)
+        y0 = y;
+      if (y > y1)
+        y1 = y;
+    }
+    if (Math.max(x1 - x0, y1 - y0) < minExtent)
+      continue;
+    const s = open ? simplifyPolyline(xs, ys, tol) : simplifyRing(xs, ys, tol);
+    if (s.xs.length < minVertices)
+      continue;
+    const flat = new Float32Array(s.xs.length * 2);
+    for (let i = 0; i < s.xs.length; i++) {
+      flat[2 * i] = s.xs[i];
+      flat[2 * i + 1] = s.ys[i];
+    }
+    out.push(flat);
+  }
+  return out;
+}
+var SIMPLIFIED_CACHE_LIMIT = 2e5;
+var RegionFeatureTable = class _RegionFeatureTable {
+  constructor(raw, tileSize = REGION_TILE_SIZE) {
+    this.raw = raw;
+    this.tileSize = tileSize;
+    this.ids = [];
+    this.labels = [];
+    this.colors = [];
+    this.planes = [];
+    this.boxes = [];
+    this.rings = [];
+    this.open = [];
+    /** Per feature, its parts as ring indices (the exterior first, then its holes). */
+    this.parts = [];
+    this.labelPoints = /* @__PURE__ */ new Map();
+    /** Each feature's area, worked out the first time its row is asked for. */
+    this.areas = /* @__PURE__ */ new Map();
+    this.byId = /* @__PURE__ */ new Map();
+    this.buckets = /* @__PURE__ */ new Map();
+    this.simplified = /* @__PURE__ */ new Map();
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    raw.forEach((feature, i) => {
+      const own = featureIdOf(feature);
+      let id = own;
+      if (id === void 0 || this.byId.has(id)) {
+        id = `#${i}`;
+        for (let k = 1; this.byId.has(id); k++)
+          id = `#${i}-${k}`;
+      }
+      this.byId.set(id, i);
+      this.ids.push(id);
+      const { label, color } = classificationOf(feature);
+      this.labels.push(label);
+      this.colors.push(color);
+      this.planes.push(feature?.geometry?.plane?.z ?? 0);
+      const { rings, open, parts } = ringsOf(feature);
+      this.rings.push(rings);
+      this.open.push(open);
+      this.parts.push(parts);
+      const box = ringsBox(rings);
+      this.boxes.push(box);
+      if (rings.length) {
+        x0 = Math.min(x0, box[0]);
+        y0 = Math.min(y0, box[1]);
+        x1 = Math.max(x1, box[2]);
+        y1 = Math.max(y1, box[3]);
+      }
+    });
+    this.bounds = x0 <= x1 ? [x0, y0, x1, y1] : null;
+    const extent = this.bounds ? Math.max(Math.abs(x0), Math.abs(y0), Math.abs(x1), Math.abs(y1)) : 0;
+    this.levels = 1 + Math.max(0, Math.ceil(Math.log2(Math.max(extent, tileSize) / tileSize)));
+  }
+  /** Parse a GeoJSON FeatureCollection string. Throws on invalid JSON or no `features`. */
+  static fromGeoJson(text, tileSize = REGION_TILE_SIZE) {
+    const parsed = JSON.parse(text);
+    if (!parsed || !Array.isArray(parsed.features)) {
+      throw new Error("Invalid GeoJson file: must contain the 'features' key.");
+    }
+    const table = new _RegionFeatureTable(parsed.features, tileSize);
+    table.describe(parsed.classHierarchy, parsed.style);
+    return table;
+  }
+  /** Attach a class hierarchy and a style hint (each ignored when not well formed). */
+  describe(hierarchy, style) {
+    this.hierarchy = readHierarchy(hierarchy) ?? this.hierarchy;
+    this.style = readStyle(style) ?? this.style;
+  }
+  /**
+   * The outlines of every feature of these classes, plane by plane, simplified for `level` (what a
+   * 3D reconstruction of the classes stacks), without the `exclude`d ids: closed features' rings,
+   * open features' polylines as `lines`, each ring with its feature (`ringGroups`). Planes without
+   * one are left out. `classes` null reads every labelled feature, each outline with its class
+   * (`ringLabels`, `lineLabels`).
+   */
+  classOutlines(classes, level, exclude = []) {
+    const wanted = classes ? new Set(classes) : null;
+    const skip = new Set(exclude);
+    const byPlane = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.ids.length; i++) {
+      const label = this.labels[i];
+      if (!label || wanted && !wanted.has(label) || skip.has(this.ids[i]))
+        continue;
+      const rings = this.ringsAt(i, level);
+      if (!rings.length)
+        continue;
+      const z = this.planes[i];
+      let plane = byPlane.get(z);
+      if (!plane)
+        byPlane.set(z, plane = { z, rings: [] });
+      if (this.open[i]) {
+        (plane.lines ?? (plane.lines = [])).push(...rings);
+        if (!wanted)
+          (plane.lineLabels ?? (plane.lineLabels = [])).push(...rings.map(() => label));
+      } else {
+        plane.rings.push(...rings);
+        (plane.ringGroups ?? (plane.ringGroups = [])).push(...rings.map(() => i));
+        if (!wanted)
+          (plane.ringLabels ?? (plane.ringLabels = [])).push(...rings.map(() => label));
+      }
+    }
+    return Array.from(byPlane.values()).sort((a, b) => a.z - b.z);
+  }
+  /** Features per class on plane `z` (null: on every plane), without the `exclude`d ids. */
+  classCounts(z, exclude = []) {
+    const skip = new Set(exclude);
+    const counts = {};
+    for (let i = 0; i < this.ids.length; i++) {
+      const label = this.labels[i];
+      if (z !== null && this.planes[i] !== z || !label || skip.has(this.ids[i]))
+        continue;
+      counts[label] = (counts[label] ?? 0) + 1;
+    }
+    return counts;
+  }
+  info() {
+    const classColors = {};
+    this.labels.forEach((label, i) => {
+      const color = this.colors[i];
+      if (label && color && !(label in classColors))
+        classColors[label] = color;
+    });
+    return {
+      featureCount: this.ids.length,
+      bounds: this.bounds,
+      tileSize: this.tileSize,
+      levels: this.levels,
+      planes: Array.from(new Set(this.planes)).sort((a, b) => a - b),
+      classColors,
+      ...this.hierarchy ? { hierarchy: this.hierarchy } : {},
+      ...this.style ? { style: this.style } : {}
+    };
+  }
+  /** One tile of plane `z`. */
+  tile(z, level, gx, gy) {
+    const { cells, wide } = this.bucketsFor(z, level);
+    const bucket = cells.get(`${gx}/${gy}`) ?? [];
+    const size = levelTileSize(level, this.tileSize);
+    const features = [];
+    const order = [];
+    for (let a = 0, w = 0; a < bucket.length || w < wide.length; ) {
+      if (w >= wide.length || a < bucket.length && bucket[a] < wide[w])
+        order.push(bucket[a++]);
+      else {
+        const i = wide[w++];
+        if (cellMeets(this.boxes[i], size, gx, gy))
+          order.push(i);
+      }
+    }
+    for (const i of order) {
+      const rings = this.ringsAt(i, level);
+      if (!rings.length)
+        continue;
+      const labels = this.labelsAt(i, level);
+      features.push({
+        id: this.ids[i],
+        label: this.labels[i],
+        color: this.colors[i],
+        bbox: this.boxes[i],
+        rings,
+        open: this.open[i],
+        ...labels ? { labels } : {}
+      });
+    }
+    return { z, level, gx, gy, features };
+  }
+  /** The raw GeoJSON features with these ids, in the order asked (unknown ids skipped). */
+  features(ids) {
+    const out = [];
+    for (const id of ids) {
+      const i = this.byId.get(id);
+      if (i !== void 0)
+        out.push({ id, feature: this.raw[i] });
+    }
+    return out;
+  }
+  /** Feature `i`'s area in px² (0 for a polyline). */
+  areaOf(i) {
+    let area = this.areas.get(i);
+    if (area === void 0) {
+      area = this.open[i] ? 0 : ringsArea(this.rings[i]);
+      this.areas.set(i, area);
+    }
+    return area;
+  }
+  /** A page of plane `z`'s features, in file order. */
+  index(z, query) {
+    const exclude = new Set(query.exclude ?? []);
+    const classes = query.classes ? new Set(query.classes) : null;
+    const needle = query.label?.trim().toLowerCase() || null;
+    const rows = [];
+    let total = 0;
+    for (let i = 0; i < this.ids.length; i++) {
+      if (this.planes[i] !== z || exclude.has(this.ids[i]))
+        continue;
+      if (needle && !(this.labels[i] ?? "").toLowerCase().includes(needle))
+        continue;
+      if (classes && !classes.has(this.labels[i] ?? ""))
+        continue;
+      if (total >= query.offset && rows.length < query.limit) {
+        rows.push({
+          id: this.ids[i],
+          label: this.labels[i],
+          color: this.colors[i],
+          bbox: this.boxes[i],
+          area: this.areaOf(i)
+        });
+      }
+      total++;
+    }
+    return { total, rows };
+  }
+  /**
+   * The source as a GeoJSON FeatureCollection string, through the working set: features whose
+   * id is in `exclude` (taken for editing, or deleted) are left out, `extra` (the working set's
+   * features) appended. Every feature keeps an `id`; the set keeps its hierarchy and style.
+   */
+  exportGeoJson(exclude, extra) {
+    const skip = new Set(exclude);
+    const parts = [];
+    this.raw.forEach((feature, i) => {
+      const id = this.ids[i];
+      if (skip.has(id))
+        return;
+      parts.push(JSON.stringify(feature.id === void 0 ? { type: "Feature", id, ...feature } : feature));
+    });
+    for (const f of extra)
+      parts.push(JSON.stringify(f));
+    return featureCollectionJson(parts, this.hierarchy, this.style);
+  }
+  /**
+   * Feature `i`'s label points (one per part with room for a label at `level`: a part under the
+   * level's minimum extent is not drawn there), from the exact geometry, computed once.
+   */
+  labelsAt(i, level) {
+    if (this.open[i] || !this.labels[i])
+      return null;
+    let points = this.labelPoints.get(i);
+    if (!points) {
+      const out = [];
+      for (const part of this.parts[i]) {
+        const pole = polylabel(part.map((r) => this.rings[i][r]));
+        if (pole && pole.distance > 0)
+          out.push(pole.x, pole.y, pole.distance);
+      }
+      points = Float32Array.from(out);
+      this.labelPoints.set(i, points);
+    }
+    const min = levelMinExtent(level) / 2;
+    if (!min)
+      return points.length ? points : null;
+    const kept = [];
+    for (let k = 0; k + 2 < points.length; k += 3)
+      if (points[k + 2] >= min)
+        kept.push(points[k], points[k + 1], points[k + 2]);
+    return kept.length ? Float32Array.from(kept) : null;
+  }
+  /** Feature `i`'s rings at `level`, simplified once and cached. */
+  ringsAt(i, level) {
+    const key = `${level}/${i}`;
+    let rings = this.simplified.get(key);
+    if (!rings) {
+      rings = simplifyRings(this.rings[i], this.open[i], level);
+      if (this.simplified.size >= SIMPLIFIED_CACHE_LIMIT) {
+        const oldest = this.simplified.keys().next().value;
+        this.simplified.delete(oldest);
+      }
+      this.simplified.set(key, rings);
+    }
+    return rings;
+  }
+  /** Entries in plane `z`'s level-`level` index: cell listings plus wide features (tests). */
+  indexEntries(z, level) {
+    const { cells, wide } = this.bucketsFor(z, level);
+    let n = wide.length;
+    for (const list of cells.values())
+      n += list.length;
+    return n;
+  }
+  /**
+   * Plane `z`'s level-`level` index, built on first use: features by tile cell (`gx/gy` → feature
+   * indices), and the wide ones (more than {@link MAX_CELLS_PER_FEATURE} cells, or past the
+   * number range), tested against a tile when it is asked for.
+   */
+  bucketsFor(z, level) {
+    const key = `${z}/${level}`;
+    let index = this.buckets.get(key);
+    if (index)
+      return index;
+    const cells = /* @__PURE__ */ new Map();
+    const wide = [];
+    const size = levelTileSize(level, this.tileSize);
+    const minExtent = levelMinExtent(level);
+    for (let i = 0; i < this.ids.length; i++) {
+      if (this.planes[i] !== z || !this.rings[i].length)
+        continue;
+      const b = this.boxes[i];
+      if (Math.max(b[2] - b[0], b[3] - b[1]) < minExtent)
+        continue;
+      const gx0 = Math.floor(b[0] / size), gx1 = Math.floor(b[2] / size), gy0 = Math.floor(b[1] / size), gy1 = Math.floor(b[3] / size);
+      if ([gx0, gx1, gy0, gy1].some(Number.isNaN))
+        continue;
+      const count = (gx1 - gx0 + 1) * (gy1 - gy0 + 1);
+      if (!(count <= MAX_CELLS_PER_FEATURE) || ![gx0, gx1, gy0, gy1].every(Number.isSafeInteger)) {
+        wide.push(i);
+        continue;
+      }
+      for (let gy = gy0; gy <= gy1; gy++) {
+        for (let gx = gx0; gx <= gx1; gx++) {
+          const id = `${gx}/${gy}`;
+          const list = cells.get(id);
+          if (list)
+            list.push(i);
+          else
+            cells.set(id, [i]);
+        }
+      }
+    }
+    index = { cells, wide };
+    this.buckets.set(key, index);
+    return index;
+  }
+};
+var MAX_CELLS_PER_FEATURE = 64;
+function cellMeets(b, size, gx, gy) {
+  return Math.floor(b[0] / size) <= gx && gx <= Math.floor(b[2] / size) && Math.floor(b[1] / size) <= gy && gy <= Math.floor(b[3] / size);
+}
+function featureIdOf(feature) {
+  const id = feature?.id ?? feature?.properties?.id;
+  return typeof id === "string" || typeof id === "number" ? String(id) : void 0;
+}
+function classificationOf(feature) {
+  const c = feature?.properties?.classification;
+  if (!c)
+    return { label: "Cell", color: null };
+  if (typeof c === "string")
+    return { label: c, color: null };
+  const color = Array.isArray(c.color) && c.color.length >= 3 ? rgbToHex([c.color[0], c.color[1], c.color[2]]) : null;
+  return { label: c.name ?? null, color };
+}
+function ringsOf(feature) {
+  const g = feature?.geometry;
+  const coords = g?.coordinates;
+  if (!g || !Array.isArray(coords))
+    return { rings: [], open: false, parts: [] };
+  const polygons = (list) => {
+    const rings = [];
+    const parts = [];
+    for (const polygon of list) {
+      const part = [];
+      for (const r of polygon) {
+        part.push(rings.length);
+        rings.push(flatRing(r, true));
+      }
+      if (part.length)
+        parts.push(part);
+    }
+    return { rings, open: false, parts };
+  };
+  switch (g.type) {
+    case "Polygon":
+      return polygons([coords]);
+    case "MultiPolygon":
+      return polygons(coords);
+    case "LineString":
+      return { rings: [flatRing(coords, false)], open: true, parts: [] };
+    case "MultiLineString":
+      return { rings: coords.map((r) => flatRing(r, false)), open: true, parts: [] };
+    default:
+      return { rings: [], open: false, parts: [] };
+  }
+}
+function featureCollectionJson(features, hierarchy, style) {
+  const head = ['"type":"FeatureCollection"'];
+  if (hierarchy?.length)
+    head.push(`"classHierarchy":${JSON.stringify(hierarchy)}`);
+  if (style)
+    head.push(`"style":${JSON.stringify(style)}`);
+  return `{${head.join(",")},"features":[${features.join(",")}]}`;
+}
+function readHierarchy(raw) {
+  if (!Array.isArray(raw))
+    return void 0;
+  const out = [];
+  for (const n of raw) {
+    if (!n || typeof n.name !== "string")
+      continue;
+    const color = Array.isArray(n.color) ? rgbToHex([+n.color[0], +n.color[1], +n.color[2]]) : n.color;
+    out.push({
+      name: n.name,
+      ...typeof n.title === "string" ? { title: n.title } : {},
+      ...typeof n.parent === "string" ? { parent: n.parent } : {},
+      ...typeof color === "string" ? { color } : {},
+      ...typeof n.order === "number" ? { order: n.order } : {}
+    });
+  }
+  return out.length ? out : void 0;
+}
+function readStyle(raw) {
+  if (!raw || typeof raw !== "object")
+    return void 0;
+  const r = raw;
+  const style = {};
+  if (typeof r.fillOpacity === "number")
+    style.fillOpacity = Math.max(0, Math.min(1, r.fillOpacity));
+  if (typeof r.stroke === "string")
+    style.stroke = r.stroke;
+  if (typeof r.strokeWidth === "number" && r.strokeWidth > 0)
+    style.strokeWidth = r.strokeWidth;
+  if (typeof r.labels === "boolean")
+    style.labels = r.labels;
+  if (typeof r.highlight === "string")
+    style.highlight = r.highlight;
+  return Object.keys(style).length ? style : void 0;
+}
+function flatRing(points, closed) {
+  let n = points?.length ?? 0;
+  if (closed && n > 1) {
+    const a = points[0], b = points[n - 1];
+    if (a[0] === b[0] && a[1] === b[1])
+      n--;
+  }
+  const out = new Float64Array(n * 2);
+  for (let i = 0; i < n; i++) {
+    out[2 * i] = +points[i][0];
+    out[2 * i + 1] = +points[i][1];
+  }
+  return out;
+}
+function ringsBox(rings) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const r of rings) {
+    for (let i = 0; i + 1 < r.length; i += 2) {
+      if (r[i] < x0)
+        x0 = r[i];
+      if (r[i] > x1)
+        x1 = r[i];
+      if (r[i + 1] < y0)
+        y0 = r[i + 1];
+      if (r[i + 1] > y1)
+        y1 = r[i + 1];
+    }
+  }
+  return [x0, y0, x1, y1];
+}
+
+// src/lib/region-source/region-source-ops.ts
+var RegionSourceTables = class {
+  constructor() {
+    this.tables = /* @__PURE__ */ new Map();
+    this.nextHandle = 1;
+  }
+  run(request) {
+    return this.dispatch(request);
+  }
+  dispatch(r) {
+    switch (r.op) {
+      case "open": {
+        const table = RegionFeatureTable.fromGeoJson(r.text, r.tileSize);
+        const handle = this.nextHandle++;
+        this.tables.set(handle, table);
+        return { handle, info: table.info() };
+      }
+      case "tile":
+        return this.table(r.handle).tile(r.z, r.level, r.gx, r.gy);
+      case "features":
+        return this.table(r.handle).features(r.ids);
+      case "index":
+        return this.table(r.handle).index(r.z, r.query);
+      case "classes":
+        return this.table(r.handle).classCounts(r.z, r.exclude);
+      case "outlines":
+        return this.table(r.handle).classOutlines(r.classes, r.level, r.exclude);
+      case "mesh":
+        return reconstruct(r.slices, r.options);
+      case "export":
+        return this.table(r.handle).exportGeoJson(r.exclude, r.extra);
+      case "close":
+        this.tables.delete(r.handle);
+        return null;
+    }
+  }
+  table(handle) {
+    const table = this.tables.get(handle);
+    if (!table)
+      throw new Error(`No open region source ${handle}.`);
+    return table;
+  }
+};
+
+// src/lib/region-source/region-source.worker.ts
+var tables = new RegionSourceTables();
+self.onmessage = (event) => {
+  const { id } = event.data;
+  let reply;
+  try {
+    reply = { id, ok: true, result: tables.run(event.data) };
+  } catch (err) {
+    reply = { id, ok: false, error: err?.message ?? String(err) };
+  }
+  self.postMessage(reply);
+};