open-plant 1.1.0

package/dist/index.js

@@ -0,0 +1,2070 @@
+var $t = Object.defineProperty;
+var Jt = (e, t, i) => t in e ? $t(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var y = (e, t, i) => Jt(e, typeof t != "symbol" ? t + "" : t, i);
+import { jsx as ft, jsxs as Mt, Fragment as Kt } from "react/jsx-runtime";
+import { useRef as O, useMemo as $, useCallback as S, useEffect as z, useState as xt } from "react";
+function It(e, t, i) {
+  const r = e.createShader(t);
+  if (!r)
+    throw new Error("Failed to create shader.");
+  if (e.shaderSource(r, i), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+    const o = e.getShaderInfoLog(r) ?? "unknown shader error";
+    throw e.deleteShader(r), new Error(o);
+  }
+  return r;
+}
+function jt(e, t, i) {
+  const r = It(e, e.VERTEX_SHADER, t), n = It(e, e.FRAGMENT_SHADER, i), o = e.createProgram();
+  if (!o)
+    throw e.deleteShader(r), e.deleteShader(n), new Error("Failed to create program.");
+  if (e.attachShader(o, r), e.attachShader(o, n), e.linkProgram(o), e.deleteShader(r), e.deleteShader(n), !e.getProgramParameter(o, e.LINK_STATUS)) {
+    const h = e.getProgramInfoLog(o) ?? "unknown link error";
+    throw e.deleteProgram(o), new Error(h);
+  }
+  return o;
+}
+function St(e, t, i) {
+  const r = e.getUniformLocation(t, i);
+  if (!r)
+    throw new Error(`Failed to get uniform location: ${i}`);
+  return r;
+}
+function Qt(e) {
+  const t = e.getContext("webgl2", {
+    alpha: !1,
+    antialias: !1,
+    depth: !1,
+    stencil: !1,
+    preserveDrawingBuffer: !1,
+    powerPreference: "high-performance"
+  });
+  if (!t)
+    throw new Error("WebGL2 is not available.");
+  return t;
+}
+let te = class {
+  constructor() {
+    y(this, "viewportWidth", 1);
+    y(this, "viewportHeight", 1);
+    y(this, "viewState", {
+      offsetX: 0,
+      offsetY: 0,
+      zoom: 1
+    });
+  }
+  setViewport(t, i) {
+    this.viewportWidth = Math.max(1, t), this.viewportHeight = Math.max(1, i);
+  }
+  getViewportSize() {
+    return {
+      width: this.viewportWidth,
+      height: this.viewportHeight
+    };
+  }
+  setViewState(t) {
+    t.offsetX !== void 0 && (this.viewState.offsetX = t.offsetX), t.offsetY !== void 0 && (this.viewState.offsetY = t.offsetY), t.zoom !== void 0 && (this.viewState.zoom = Math.max(1e-4, t.zoom));
+  }
+  getViewState() {
+    return { ...this.viewState };
+  }
+  getMatrix() {
+    const t = this.viewportWidth / this.viewState.zoom, i = this.viewportHeight / this.viewState.zoom, r = 2 / t, n = -2 / i, o = -1 - this.viewState.offsetX * r, a = 1 - this.viewState.offsetY * n;
+    return new Float32Array([
+      r,
+      0,
+      0,
+      0,
+      n,
+      0,
+      o,
+      a,
+      1
+    ]);
+  }
+};
+const ee = `#version 300 es
+precision highp float;
+
+in vec2 aUnit;
+in vec2 aUv;
+
+uniform mat3 uCamera;
+uniform vec4 uBounds;
+
+out vec2 vUv;
+
+void main() {
+  vec2 world = vec2(
+    mix(uBounds.x, uBounds.z, aUnit.x),
+    mix(uBounds.y, uBounds.w, aUnit.y)
+  );
+  vec3 clip = uCamera * vec3(world, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vUv = aUv;
+}
+`, ie = `#version 300 es
+precision highp float;
+
+in vec2 vUv;
+uniform sampler2D uTexture;
+
+out vec4 outColor;
+
+void main() {
+  outColor = texture(uTexture, vUv);
+}
+`;
+class re {
+  constructor(t) {
+    y(this, "canvas");
+    y(this, "gl");
+    y(this, "camera", new te());
+    y(this, "imageWidth");
+    y(this, "imageHeight");
+    y(this, "clearColor");
+    y(this, "program");
+    y(this, "vao");
+    y(this, "quadBuffer");
+    y(this, "uCameraLocation");
+    y(this, "uBoundsLocation");
+    y(this, "uTextureLocation");
+    y(this, "resizeObserver");
+    y(this, "tiles", []);
+    y(this, "frameId", null);
+    y(this, "loadVersion", 0);
+    y(this, "destroyed", !1);
+    y(this, "fitted", !1);
+    y(this, "controlledViewState", !1);
+    this.canvas = t.canvas, this.imageWidth = Math.max(1, t.imageWidth), this.imageHeight = Math.max(1, t.imageHeight), this.clearColor = t.clearColor ?? [0.03, 0.05, 0.08, 1], this.gl = Qt(this.canvas), this.program = jt(this.gl, ee, ie);
+    const i = this.gl.createVertexArray(), r = this.gl.createBuffer();
+    if (!i || !r)
+      throw new Error("Failed to create WebGL buffers.");
+    this.vao = i, this.quadBuffer = r, this.gl.bindVertexArray(this.vao), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.quadBuffer);
+    const n = new Float32Array([
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      1,
+      1,
+      1,
+      1,
+      1
+    ]);
+    this.gl.bufferData(this.gl.ARRAY_BUFFER, n, this.gl.STATIC_DRAW);
+    const o = this.gl.getAttribLocation(this.program, "aUnit"), a = this.gl.getAttribLocation(this.program, "aUv");
+    if (o < 0 || a < 0)
+      throw new Error("Failed to get attribute locations.");
+    const h = 4 * Float32Array.BYTES_PER_ELEMENT;
+    this.gl.enableVertexAttribArray(o), this.gl.vertexAttribPointer(
+      o,
+      2,
+      this.gl.FLOAT,
+      !1,
+      h,
+      0
+    ), this.gl.enableVertexAttribArray(a), this.gl.vertexAttribPointer(
+      a,
+      2,
+      this.gl.FLOAT,
+      !1,
+      h,
+      2 * Float32Array.BYTES_PER_ELEMENT
+    ), this.gl.bindVertexArray(null), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null), this.uCameraLocation = St(
+      this.gl,
+      this.program,
+      "uCamera"
+    ), this.uBoundsLocation = St(
+      this.gl,
+      this.program,
+      "uBounds"
+    ), this.uTextureLocation = St(
+      this.gl,
+      this.program,
+      "uTexture"
+    ), t.initialViewState && (this.controlledViewState = !0, this.camera.setViewState(t.initialViewState)), this.resizeObserver = new ResizeObserver(() => {
+      this.resize();
+    }), this.resizeObserver.observe(this.canvas), this.resize();
+  }
+  async setTiles(t) {
+    if (this.destroyed)
+      return;
+    const i = ++this.loadVersion, r = await Promise.all(
+      t.map(async (n) => await this.loadTile(n, i))
+    );
+    if (this.destroyed || i !== this.loadVersion) {
+      for (const n of r)
+        n && this.gl.deleteTexture(n.texture);
+      return;
+    }
+    this.disposeTiles(this.tiles), this.tiles = r.filter((n) => n !== null), this.requestRender();
+  }
+  setViewState(t) {
+    this.controlledViewState = !0, this.camera.setViewState(t), this.requestRender();
+  }
+  getViewState() {
+    return this.camera.getViewState();
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.loadVersion += 1, this.frameId !== null && (cancelAnimationFrame(this.frameId), this.frameId = null), this.resizeObserver.disconnect(), this.disposeTiles(this.tiles), this.tiles = [], this.gl.deleteBuffer(this.quadBuffer), this.gl.deleteVertexArray(this.vao), this.gl.deleteProgram(this.program));
+  }
+  async loadTile(t, i) {
+    try {
+      const r = await fetch(t.url);
+      if (!r.ok)
+        throw new Error(
+          `Tile fetch failed: ${r.status} ${r.statusText}`
+        );
+      const n = await r.blob(), o = await createImageBitmap(n);
+      if (this.destroyed || i !== this.loadVersion)
+        return o.close(), null;
+      const a = this.gl.createTexture();
+      if (!a)
+        throw o.close(), new Error("Failed to create tile texture.");
+      return this.gl.bindTexture(this.gl.TEXTURE_2D, a), this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, 1), this.gl.texParameteri(
+        this.gl.TEXTURE_2D,
+        this.gl.TEXTURE_WRAP_S,
+        this.gl.CLAMP_TO_EDGE
+      ), this.gl.texParameteri(
+        this.gl.TEXTURE_2D,
+        this.gl.TEXTURE_WRAP_T,
+        this.gl.CLAMP_TO_EDGE
+      ), this.gl.texParameteri(
+        this.gl.TEXTURE_2D,
+        this.gl.TEXTURE_MIN_FILTER,
+        this.gl.LINEAR
+      ), this.gl.texParameteri(
+        this.gl.TEXTURE_2D,
+        this.gl.TEXTURE_MAG_FILTER,
+        this.gl.LINEAR
+      ), this.gl.texImage2D(
+        this.gl.TEXTURE_2D,
+        0,
+        this.gl.RGBA,
+        this.gl.RGBA,
+        this.gl.UNSIGNED_BYTE,
+        o
+      ), this.gl.bindTexture(this.gl.TEXTURE_2D, null), o.close(), {
+        id: t.id,
+        bounds: t.bounds,
+        texture: a
+      };
+    } catch (r) {
+      return console.error(`[M1TileRenderer] tile load failed: ${t.id}`, r), null;
+    }
+  }
+  resize() {
+    if (this.destroyed)
+      return;
+    const t = this.canvas.getBoundingClientRect(), i = Math.max(1, t.width || this.canvas.clientWidth || 1), r = Math.max(1, t.height || this.canvas.clientHeight || 1), n = Math.max(1, window.devicePixelRatio || 1), o = Math.max(1, Math.round(i * n)), a = Math.max(1, Math.round(r * n));
+    (this.canvas.width !== o || this.canvas.height !== a) && (this.canvas.width = o, this.canvas.height = a), this.camera.setViewport(i, r), this.gl.viewport(0, 0, this.canvas.width, this.canvas.height), !this.fitted && !this.controlledViewState && (this.fitToImage(), this.fitted = !0), this.requestRender();
+  }
+  fitToImage() {
+    const t = this.camera.getViewportSize(), i = Math.min(
+      t.width / this.imageWidth,
+      t.height / this.imageHeight
+    ), r = Number.isFinite(i) && i > 0 ? i : 1, n = t.width / r, o = t.height / r, a = (this.imageWidth - n) * 0.5, h = (this.imageHeight - o) * 0.5;
+    this.camera.setViewState({
+      zoom: r,
+      offsetX: a,
+      offsetY: h
+    });
+  }
+  requestRender() {
+    this.frameId !== null || this.destroyed || (this.frameId = requestAnimationFrame(() => {
+      this.frameId = null, this.render();
+    }));
+  }
+  render() {
+    if (!this.destroyed) {
+      this.gl.clearColor(
+        this.clearColor[0],
+        this.clearColor[1],
+        this.clearColor[2],
+        this.clearColor[3]
+      ), this.gl.clear(this.gl.COLOR_BUFFER_BIT), this.gl.useProgram(this.program), this.gl.bindVertexArray(this.vao), this.gl.uniformMatrix3fv(
+        this.uCameraLocation,
+        !1,
+        this.camera.getMatrix()
+      ), this.gl.uniform1i(this.uTextureLocation, 0);
+      for (const t of this.tiles)
+        this.gl.activeTexture(this.gl.TEXTURE0), this.gl.bindTexture(this.gl.TEXTURE_2D, t.texture), this.gl.uniform4f(
+          this.uBoundsLocation,
+          t.bounds[0],
+          t.bounds[1],
+          t.bounds[2],
+          t.bounds[3]
+        ), this.gl.drawArrays(this.gl.TRIANGLE_STRIP, 0, 4);
+      this.gl.bindTexture(this.gl.TEXTURE_2D, null), this.gl.bindVertexArray(null);
+    }
+  }
+  disposeTiles(t) {
+    for (const i of t)
+      this.gl.deleteTexture(i.texture);
+  }
+}
+const Nt = [
+  160,
+  160,
+  160,
+  255
+];
+function k(e, t, i) {
+  return Math.max(t, Math.min(i, e));
+}
+function Wt(e, t, i) {
+  const r = Number(e), n = Number(t), o = Number(i);
+  return !Number.isFinite(r) || r <= 0 ? 1 : !Number.isFinite(n) || !Number.isFinite(o) ? r : Math.pow(2, n - o) * r;
+}
+function Ue(e, t, i) {
+  let n = 100 * Wt(e, t, i);
+  if (Number(e)) {
+    let o = "μm";
+    return n > 1e3 && (n /= 1e3, o = "mm"), `${n.toPrecision(3)} ${o}`;
+  }
+  return `${Math.round(n * 1e3) / 1e3} pixels`;
+}
+function Be(e, t) {
+  return !e && !t ? !0 : !e || !t ? !1 : Math.abs((e.zoom ?? 0) - (t.zoom ?? 0)) < 1e-6 && Math.abs((e.offsetX ?? 0) - (t.offsetX ?? 0)) < 1e-6 && Math.abs((e.offsetY ?? 0) - (t.offsetY ?? 0)) < 1e-6;
+}
+function Xe(e) {
+  const t = String(e ?? "").trim();
+  if (!t) return "";
+  if (/^bearer\s+/i.test(t)) {
+    const i = t.replace(/^bearer\s+/i, "").trim();
+    return i ? `Bearer ${i}` : "";
+  }
+  return `Bearer ${t}`;
+}
+function ne(e) {
+  const i = String(e ?? "").trim().match(/^#?([0-9a-fA-F]{6})$/);
+  if (!i) return [...Nt];
+  const r = Number.parseInt(i[1], 16);
+  return [r >> 16 & 255, r >> 8 & 255, r & 255, 255];
+}
+function Le(e) {
+  const t = [
+    [...Nt]
+  ], i = /* @__PURE__ */ new Map();
+  for (const n of e ?? []) {
+    const o = String(n?.termId ?? "");
+    !o || i.has(o) || (i.set(o, t.length), t.push(ne(n?.termColor)));
+  }
+  const r = new Uint8Array(t.length * 4);
+  for (let n = 0; n < t.length; n += 1)
+    r[n * 4] = t[n][0], r[n * 4 + 1] = t[n][1], r[n * 4 + 2] = t[n][2], r[n * 4 + 3] = t[n][3];
+  return { colors: r, termToPaletteIndex: i };
+}
+function Ct(e, t, i) {
+  const r = e.createShader(e.VERTEX_SHADER), n = e.createShader(e.FRAGMENT_SHADER);
+  if (!r || !n)
+    throw new Error("Shader allocation failed");
+  if (e.shaderSource(r, t), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS))
+    throw new Error(e.getShaderInfoLog(r) || "vertex compile failed");
+  if (e.shaderSource(n, i), e.compileShader(n), !e.getShaderParameter(n, e.COMPILE_STATUS))
+    throw new Error(e.getShaderInfoLog(n) || "fragment compile failed");
+  const o = e.createProgram();
+  if (!o)
+    throw new Error("Program allocation failed");
+  if (e.attachShader(o, r), e.attachShader(o, n), e.linkProgram(o), e.deleteShader(r), e.deleteShader(n), !e.getProgramParameter(o, e.LINK_STATUS))
+    throw new Error(e.getProgramInfoLog(o) || "program link failed");
+  return o;
+}
+const oe = "rgba(255, 77, 79, 0.16)", se = 3, ae = 2, kt = 96, ce = 1, he = [], Et = [], _t = 1e3, Ot = 2, Ht = 2, le = 0.2, ut = {
+  color: "#ff4d4f",
+  width: 2,
+  lineJoin: "round",
+  lineCap: "round",
+  shadowColor: "rgba(0, 0, 0, 0)",
+  shadowBlur: 0,
+  shadowOffsetX: 0,
+  shadowOffsetY: 0
+}, st = {
+  fontFamily: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace",
+  fontSize: 12,
+  fontWeight: 500,
+  textColor: "#ffffff",
+  backgroundColor: "rgba(8, 14, 22, 0.88)",
+  borderColor: "rgba(255, 77, 79, 0.85)",
+  borderWidth: 1,
+  paddingX: 6,
+  paddingY: 4,
+  offsetY: 10,
+  borderRadius: 3
+};
+function vt(e, t, i) {
+  return Math.max(t, Math.min(i, e));
+}
+function wt(e) {
+  return e === "stamp-rectangle" || e === "stamp-circle" || e === "stamp-rectangle-2mm2" || e === "stamp-circle-2mm2" || e === "stamp-circle-hpf-0.2mm2";
+}
+function yt(e, t) {
+  return typeof e != "number" || !Number.isFinite(e) || e <= 0 ? t : e;
+}
+function ue(e) {
+  return {
+    rectangleAreaMm2: yt(
+      e?.rectangleAreaMm2,
+      Ot
+    ),
+    circleAreaMm2: yt(
+      e?.circleAreaMm2,
+      Ht
+    )
+  };
+}
+function fe(e) {
+  return e * _t * _t;
+}
+function de(e, t) {
+  return !e || !Number.isFinite(t) || t <= 0 ? [] : dt([
+    [e[0] - t, e[1] - t],
+    [e[0] + t, e[1] - t],
+    [e[0] + t, e[1] + t],
+    [e[0] - t, e[1] + t]
+  ]);
+}
+function me(e, t, i = kt) {
+  if (!e || !Number.isFinite(t) || t <= 0) return [];
+  const r = [];
+  for (let n = 0; n <= i; n += 1) {
+    const o = n / i * Math.PI * 2;
+    r.push([
+      e[0] + Math.cos(o) * t,
+      e[1] + Math.sin(o) * t
+    ]);
+  }
+  return dt(r);
+}
+function dt(e) {
+  if (!Array.isArray(e) || e.length < 3) return [];
+  const t = e.map(([n, o]) => [n, o]), i = t[0], r = t[t.length - 1];
+  return !i || !r ? [] : ((i[0] !== r[0] || i[1] !== r[1]) && t.push([i[0], i[1]]), t);
+}
+function zt(e, t) {
+  return !e || !t ? [] : dt([
+    [e[0], e[1]],
+    [t[0], e[1]],
+    [t[0], t[1]],
+    [e[0], t[1]]
+  ]);
+}
+function Ft(e, t, i = kt) {
+  if (!e || !t) return [];
+  const r = (e[0] + t[0]) * 0.5, n = (e[1] + t[1]) * 0.5, o = Math.hypot(t[0] - e[0], t[1] - e[1]) * 0.5;
+  if (o < 1) return [];
+  const a = [];
+  for (let h = 0; h <= i; h += 1) {
+    const u = h / i * Math.PI * 2;
+    a.push([
+      r + Math.cos(u) * o,
+      n + Math.sin(u) * o
+    ]);
+  }
+  return dt(a);
+}
+function Rt(e) {
+  if (!Array.isArray(e) || e.length < 4) return 0;
+  let t = 0;
+  for (let i = 0; i < e.length - 1; i += 1) {
+    const r = e[i], n = e[i + 1];
+    t += r[0] * n[1] - n[0] * r[1];
+  }
+  return Math.abs(t * 0.5);
+}
+function Ut(e) {
+  if (!Array.isArray(e) || e.length === 0) return [0, 0, 0, 0];
+  let t = 1 / 0, i = 1 / 0, r = -1 / 0, n = -1 / 0;
+  for (const [o, a] of e)
+    o < t && (t = o), o > r && (r = o), a < i && (i = a), a > n && (n = a);
+  return [t, i, r, n];
+}
+function Bt(e) {
+  return Array.isArray(e) && e.length >= 4 && Rt(e) > ce;
+}
+function bt(e, t, i, r = !1, n = !1) {
+  if (t.length !== 0) {
+    e.beginPath(), e.moveTo(t[0][0], t[0][1]);
+    for (let o = 1; o < t.length; o += 1)
+      e.lineTo(t[o][0], t[o][1]);
+    r && e.closePath(), n && r && (e.fillStyle = oe, e.fill()), e.strokeStyle = i.color, e.lineWidth = i.width, e.lineJoin = i.lineJoin, e.lineCap = i.lineCap, e.shadowColor = i.shadowColor, e.shadowBlur = i.shadowBlur, e.shadowOffsetX = i.shadowOffsetX, e.shadowOffsetY = i.shadowOffsetY, e.setLineDash(i.lineDash), e.stroke(), e.setLineDash(Et), e.shadowColor = "rgba(0, 0, 0, 0)", e.shadowBlur = 0, e.shadowOffsetX = 0, e.shadowOffsetY = 0;
+  }
+}
+function Gt(e) {
+  const t = Array.isArray(e?.lineDash) ? e.lineDash.filter((a) => Number.isFinite(a) && a >= 0) : Et, i = typeof e?.width == "number" && Number.isFinite(e.width) ? Math.max(0, e.width) : ut.width, r = typeof e?.shadowBlur == "number" && Number.isFinite(e.shadowBlur) ? Math.max(0, e.shadowBlur) : ut.shadowBlur, n = typeof e?.shadowOffsetX == "number" && Number.isFinite(e.shadowOffsetX) ? e.shadowOffsetX : ut.shadowOffsetX, o = typeof e?.shadowOffsetY == "number" && Number.isFinite(e.shadowOffsetY) ? e.shadowOffsetY : ut.shadowOffsetY;
+  return {
+    color: e?.color || ut.color,
+    width: i,
+    lineDash: t.length ? t : Et,
+    lineJoin: e?.lineJoin || ut.lineJoin,
+    lineCap: e?.lineCap || ut.lineCap,
+    shadowColor: e?.shadowColor || ut.shadowColor,
+    shadowBlur: r,
+    shadowOffsetX: n,
+    shadowOffsetY: o
+  };
+}
+function Xt(e, t) {
+  return t ? Gt({
+    color: t.color ?? e.color,
+    width: t.width ?? e.width,
+    lineDash: t.lineDash ?? e.lineDash,
+    lineJoin: t.lineJoin ?? e.lineJoin,
+    lineCap: t.lineCap ?? e.lineCap,
+    shadowColor: t.shadowColor ?? e.shadowColor,
+    shadowBlur: t.shadowBlur ?? e.shadowBlur,
+    shadowOffsetX: t.shadowOffsetX ?? e.shadowOffsetX,
+    shadowOffsetY: t.shadowOffsetY ?? e.shadowOffsetY
+  }) : e;
+}
+function Lt(e, t) {
+  return e == null || t === null || t === void 0 ? !1 : String(e) === String(t);
+}
+function ge(e) {
+  const t = typeof e?.paddingX == "number" && Number.isFinite(e.paddingX) ? Math.max(0, e.paddingX) : st.paddingX, i = typeof e?.paddingY == "number" && Number.isFinite(e.paddingY) ? Math.max(0, e.paddingY) : st.paddingY, r = typeof e?.fontSize == "number" && Number.isFinite(e.fontSize) ? Math.max(8, e.fontSize) : st.fontSize, n = typeof e?.borderWidth == "number" && Number.isFinite(e.borderWidth) ? Math.max(0, e.borderWidth) : st.borderWidth, o = typeof e?.offsetY == "number" && Number.isFinite(e.offsetY) ? e.offsetY : st.offsetY, a = typeof e?.borderRadius == "number" && Number.isFinite(e.borderRadius) ? Math.max(0, e.borderRadius) : st.borderRadius;
+  return {
+    fontFamily: e?.fontFamily || st.fontFamily,
+    fontSize: r,
+    fontWeight: e?.fontWeight || st.fontWeight,
+    textColor: e?.textColor || st.textColor,
+    backgroundColor: e?.backgroundColor || st.backgroundColor,
+    borderColor: e?.borderColor || st.borderColor,
+    borderWidth: n,
+    paddingX: t,
+    paddingY: i,
+    offsetY: o,
+    borderRadius: a
+  };
+}
+function pe(e, t, i, r, n, o) {
+  const a = Math.max(0, Math.min(o, r * 0.5, n * 0.5));
+  e.beginPath(), e.moveTo(t + a, i), e.lineTo(t + r - a, i), e.quadraticCurveTo(t + r, i, t + r, i + a), e.lineTo(t + r, i + n - a), e.quadraticCurveTo(t + r, i + n, t + r - a, i + n), e.lineTo(t + a, i + n), e.quadraticCurveTo(t, i + n, t, i + n - a), e.lineTo(t, i + a), e.quadraticCurveTo(t, i, t + a, i), e.closePath();
+}
+function we(e) {
+  if (!e.length) return null;
+  let t = 1 / 0;
+  for (const n of e)
+    n[1] < t && (t = n[1]);
+  if (!Number.isFinite(t)) return null;
+  let i = 1 / 0, r = -1 / 0;
+  for (const n of e)
+    Math.abs(n[1] - t) > 0.5 || (n[0] < i && (i = n[0]), n[0] > r && (r = n[0]));
+  return !Number.isFinite(i) || !Number.isFinite(r) ? null : [(i + r) * 0.5, t];
+}
+function be(e, t, i, r, n, o) {
+  const a = t.trim();
+  if (!a) return;
+  e.save(), e.font = `${o.fontWeight} ${o.fontSize}px ${o.fontFamily}`, e.textAlign = "center", e.textBaseline = "middle";
+  const u = e.measureText(a).width + o.paddingX * 2, m = o.fontSize + o.paddingY * 2, T = vt(
+    i[0],
+    u * 0.5 + 1,
+    r - u * 0.5 - 1
+  ), P = vt(
+    i[1] - o.offsetY,
+    m * 0.5 + 1,
+    n - m * 0.5 - 1
+  ), F = T - u * 0.5, q = P - m * 0.5;
+  e.fillStyle = o.backgroundColor, e.strokeStyle = o.borderColor, e.lineWidth = o.borderWidth, pe(
+    e,
+    F,
+    q,
+    u,
+    m,
+    o.borderRadius
+  ), e.fill(), o.borderWidth > 0 && e.stroke(), e.fillStyle = o.textColor, e.fillText(a, T, P + 0.5), e.restore();
+}
+function Dt(e, t, i) {
+  return [vt(e[0], 0, t), vt(e[1], 0, i)];
+}
+function Pt(e) {
+  if (!Array.isArray(e) || e.length < 2) return null;
+  const t = Number(e[0]), i = Number(e[1]);
+  return !Number.isFinite(t) || !Number.isFinite(i) ? null : [t, i];
+}
+function Te({
+  tool: e,
+  imageWidth: t,
+  imageHeight: i,
+  imageMpp: r,
+  imageZoom: n,
+  stampOptions: o,
+  projectorRef: a,
+  onDrawComplete: h,
+  enabled: u,
+  viewStateSignal: m,
+  persistedRegions: T,
+  persistedPolygons: P,
+  regionStrokeStyle: F,
+  regionStrokeHoverStyle: q,
+  regionStrokeActiveStyle: K,
+  hoveredRegionId: Q = null,
+  activeRegionId: at = null,
+  regionLabelStyle: tt,
+  invalidateRef: D,
+  className: et,
+  style: Y
+}) {
+  const _ = O(null), nt = O(!1), N = O(e), Z = O({
+    isDrawing: !1,
+    pointerId: null,
+    start: null,
+    current: null,
+    points: [],
+    stampCenter: null
+  }), E = u ?? e !== "cursor", H = $(() => T && T.length > 0 ? T : !P || P.length === 0 ? he : P.map((s, c) => ({
+    id: c,
+    coordinates: s
+  })), [T, P]), R = $(
+    () => Gt(F),
+    [F]
+  ), W = $(
+    () => Xt(R, q),
+    [R, q]
+  ), ct = $(
+    () => Xt(R, K),
+    [R, K]
+  ), ht = $(
+    () => ge(tt),
+    [tt]
+  ), mt = $(
+    () => ue(o),
+    [o]
+  ), lt = $(
+    () => ({
+      position: "absolute",
+      inset: 0,
+      zIndex: 2,
+      width: "100%",
+      height: "100%",
+      display: "block",
+      touchAction: "none",
+      pointerEvents: E ? "auto" : "none",
+      cursor: E ? "crosshair" : "default",
+      ...Y
+    }),
+    [E, Y]
+  ), ot = S(() => {
+    const s = _.current;
+    if (!s) return;
+    const c = s.getBoundingClientRect(), d = Math.max(1, window.devicePixelRatio || 1), v = Math.max(1, Math.round(c.width * d)), A = Math.max(1, Math.round(c.height * d));
+    (s.width !== v || s.height !== A) && (s.width = v, s.height = A);
+  }, []), f = S(
+    (s) => {
+      const c = a.current;
+      if (!c || s.length === 0) return [];
+      const d = new Array(s.length);
+      for (let v = 0; v < s.length; v += 1) {
+        const A = Pt(
+          c.worldToScreen(s[v][0], s[v][1])
+        );
+        if (!A) return [];
+        d[v] = A;
+      }
+      return d;
+    },
+    [a]
+  ), p = S(
+    (s) => {
+      if (!Number.isFinite(s) || s <= 0) return 0;
+      const c = typeof r == "number" && Number.isFinite(r) && r > 0 ? r : 1, d = typeof n == "number" && Number.isFinite(n) ? n : 0, v = a.current?.getViewState?.().zoom, A = typeof v == "number" && Number.isFinite(v) && v > 0 ? v : 1, l = d + Math.log2(A), g = Math.max(
+        1e-9,
+        Wt(c, d, l)
+      );
+      return s / g / A;
+    },
+    [r, n, a]
+  ), w = S(
+    (s, c) => {
+      if (!c) return [];
+      let d = 0;
+      if (s === "stamp-rectangle" || s === "stamp-rectangle-2mm2" ? d = s === "stamp-rectangle-2mm2" ? Ot : mt.rectangleAreaMm2 : (s === "stamp-circle" || s === "stamp-circle-2mm2" || s === "stamp-circle-hpf-0.2mm2") && (d = s === "stamp-circle-hpf-0.2mm2" ? le : s === "stamp-circle-2mm2" ? Ht : mt.circleAreaMm2), !Number.isFinite(d) || d <= 0) return [];
+      const v = fe(d);
+      let A = [];
+      if (s === "stamp-rectangle" || s === "stamp-rectangle-2mm2") {
+        const l = p(Math.sqrt(v) * 0.5);
+        A = de(c, l);
+      } else if (s === "stamp-circle" || s === "stamp-circle-2mm2" || s === "stamp-circle-hpf-0.2mm2") {
+        const l = p(Math.sqrt(v / Math.PI));
+        A = me(c, l);
+      }
+      return A.length ? A.map((l) => Dt(l, t, i)) : [];
+    },
+    [p, t, i, mt]
+  ), x = S(() => {
+    const s = Z.current;
+    return wt(e) ? w(e, s.stampCenter) : s.isDrawing ? e === "freehand" ? s.points : e === "rectangle" ? zt(s.start, s.current) : e === "circular" ? Ft(s.start, s.current) : [] : [];
+  }, [e, w]), U = S(() => {
+    ot();
+    const s = _.current;
+    if (!s) return;
+    const c = s.getContext("2d");
+    if (!c) return;
+    const d = Math.max(1, window.devicePixelRatio || 1), v = s.width / d, A = s.height / d;
+    if (c.setTransform(1, 0, 0, 1, 0, 0), c.clearRect(0, 0, s.width, s.height), c.setTransform(d, 0, 0, d, 0, 0), H.length > 0)
+      for (let l = 0; l < H.length; l += 1) {
+        const g = H[l], I = g?.coordinates;
+        if (!I || I.length < 3) continue;
+        const C = dt(I), G = f(C);
+        if (G.length >= 4) {
+          const pt = g.id ?? l, Zt = Lt(at, pt) ? ct : Lt(Q, pt) ? W : R;
+          bt(c, G, Zt, !0, !1);
+        }
+      }
+    if (E) {
+      const l = x();
+      if (l.length > 0)
+        if (e === "freehand") {
+          const g = f(l);
+          g.length >= 2 && bt(c, g, R, !1, !1), g.length >= 3 && bt(
+            c,
+            f(dt(l)),
+            R,
+            !0,
+            !0
+          );
+        } else {
+          const g = f(l);
+          g.length >= 4 && bt(c, g, R, !0, !0);
+        }
+    }
+    if (H.length > 0)
+      for (const l of H) {
+        if (!l.label) continue;
+        const g = l?.coordinates;
+        if (!g || g.length < 3) continue;
+        const I = dt(g), C = we(I);
+        if (!C) continue;
+        const G = Pt(
+          a.current?.worldToScreen(C[0], C[1]) ?? []
+        );
+        G && be(
+          c,
+          l.label,
+          G,
+          v,
+          A,
+          ht
+        );
+      }
+  }, [
+    E,
+    e,
+    x,
+    ot,
+    f,
+    a,
+    H,
+    Q,
+    at,
+    R,
+    W,
+    ct,
+    ht
+  ]), b = S(() => {
+    nt.current || (nt.current = !0, requestAnimationFrame(() => {
+      nt.current = !1, U();
+    }));
+  }, [U]), V = S(() => {
+    const s = Z.current, c = _.current;
+    if (c && s.pointerId !== null && c.hasPointerCapture(s.pointerId))
+      try {
+        c.releasePointerCapture(s.pointerId);
+      } catch {
+      }
+    s.isDrawing = !1, s.pointerId = null, s.start = null, s.current = null, s.points = [], s.stampCenter = null;
+  }, []), B = S(
+    (s) => {
+      const c = a.current;
+      if (!c || t <= 0 || i <= 0) return null;
+      const d = Pt(
+        c.screenToWorld(s.clientX, s.clientY)
+      );
+      return d ? Dt(d, t, i) : null;
+    },
+    [a, t, i]
+  ), J = S(() => {
+    const s = Z.current;
+    if (!s.isDrawing) {
+      V(), b();
+      return;
+    }
+    let c = [];
+    e === "freehand" ? s.points.length >= se && (c = dt(s.points)) : e === "rectangle" ? c = zt(s.start, s.current) : e === "circular" && (c = Ft(s.start, s.current)), (e === "freehand" || e === "rectangle" || e === "circular") && Bt(c) && h && h({
+      tool: e,
+      coordinates: c,
+      bbox: Ut(c),
+      areaPx: Rt(c)
+    }), V(), b();
+  }, [e, h, V, b]), it = S(
+    (s, c) => {
+      const d = w(s, c);
+      !Bt(d) || !h || h({
+        tool: s,
+        coordinates: d,
+        bbox: Ut(d),
+        areaPx: Rt(d)
+      });
+    },
+    [w, h]
+  ), j = S(
+    (s) => {
+      if (!E || e === "cursor" || s.button !== 0) return;
+      const c = B(s);
+      if (!c) return;
+      if (s.preventDefault(), s.stopPropagation(), wt(e)) {
+        const A = Z.current;
+        A.stampCenter = c, it(e, c), b();
+        return;
+      }
+      const d = _.current;
+      d && d.setPointerCapture(s.pointerId);
+      const v = Z.current;
+      v.isDrawing = !0, v.pointerId = s.pointerId, v.start = c, v.current = c, v.points = e === "freehand" ? [c] : [], b();
+    },
+    [E, e, B, it, b]
+  ), M = S(
+    (s) => {
+      if (!E || e === "cursor") return;
+      const c = B(s);
+      if (!c) return;
+      if (wt(e)) {
+        const v = Z.current;
+        v.stampCenter = c, s.preventDefault(), s.stopPropagation(), b();
+        return;
+      }
+      const d = Z.current;
+      if (!(!d.isDrawing || d.pointerId !== s.pointerId)) {
+        if (s.preventDefault(), s.stopPropagation(), e === "freehand") {
+          const v = a.current, A = Math.max(1e-6, v?.getViewState?.().zoom ?? 1), l = ae / A, g = l * l, I = d.points[d.points.length - 1];
+          if (!I)
+            d.points.push(c);
+          else {
+            const C = c[0] - I[0], G = c[1] - I[1];
+            C * C + G * G >= g && d.points.push(c);
+          }
+        } else
+          d.current = c;
+        b();
+      }
+    },
+    [E, e, B, b, a]
+  ), X = S(
+    (s) => {
+      const c = Z.current;
+      if (!c.isDrawing || c.pointerId !== s.pointerId) return;
+      s.preventDefault(), s.stopPropagation();
+      const d = _.current;
+      if (d && d.hasPointerCapture(s.pointerId))
+        try {
+          d.releasePointerCapture(s.pointerId);
+        } catch {
+        }
+      J();
+    },
+    [J]
+  ), L = S(() => {
+    if (!wt(e)) return;
+    const s = Z.current;
+    s.stampCenter && (s.stampCenter = null, b());
+  }, [e, b]);
+  return z(() => {
+    ot(), b();
+    const s = _.current;
+    if (!s) return;
+    const c = new ResizeObserver(() => {
+      ot(), b();
+    });
+    return c.observe(s), () => {
+      c.disconnect();
+    };
+  }, [ot, b]), z(() => {
+    E || V(), b();
+  }, [E, b, V]), z(() => {
+    N.current !== e && (N.current = e, V(), b());
+  }, [e, V, b]), z(() => {
+    b();
+  }, [m, H, b]), z(() => {
+    if (D)
+      return D.current = b, () => {
+        D.current === b && (D.current = null);
+      };
+  }, [D, b]), z(() => {
+    if (!E) return;
+    const s = (c) => {
+      c.key === "Escape" && (V(), b());
+    };
+    return window.addEventListener("keydown", s), () => {
+      window.removeEventListener("keydown", s);
+    };
+  }, [E, V, b]), /* @__PURE__ */ ft(
+    "canvas",
+    {
+      ref: _,
+      className: et,
+      style: lt,
+      onPointerDown: j,
+      onPointerMove: M,
+      onPointerUp: X,
+      onPointerCancel: X,
+      onPointerLeave: L,
+      onContextMenu: (s) => {
+        E && s.preventDefault();
+      },
+      onWheel: (s) => {
+        E && s.preventDefault();
+      }
+    }
+  );
+}
+function De(e, t) {
+  const i = e?.imsInfo || {}, r = Number(i.width ?? e?.width ?? 0), n = Number(i.height ?? e?.height ?? 0), o = Number(i.tileSize ?? e?.tileSize ?? 0), a = Number(i.zoom ?? e?.zoom ?? 0), h = String(i.path ?? e?.path ?? ""), u = Number(i.mpp ?? e?.mpp ?? 0);
+  if (!r || !n || !o || !h)
+    throw new Error(
+      "이미지 메타데이터가 불완전합니다. width/height/tileSize/path 확인 필요"
+    );
+  const m = Array.isArray(e?.terms) ? e.terms.map((T) => ({
+    termId: String(T?.termId ?? ""),
+    termName: String(T?.termName ?? ""),
+    termColor: String(T?.termColor ?? "")
+  })) : [];
+  return {
+    id: e?._id || "unknown",
+    name: e?.name || "unknown",
+    width: r,
+    height: n,
+    mpp: Number.isFinite(u) && u > 0 ? u : void 0,
+    tileSize: o,
+    maxTierZoom: Number.isFinite(a) ? Math.max(0, Math.floor(a)) : 0,
+    tilePath: h,
+    tileBaseUrl: t,
+    terms: m
+  };
+}
+function qt(e, t, i, r) {
+  const n = e.tilePath.startsWith("/") ? e.tilePath : `/${e.tilePath}`;
+  return `${e.tileBaseUrl}${n}/${t}/${r}_${i}.webp`;
+}
+const rt = {
+  width: 220,
+  height: 140,
+  margin: 16,
+  position: "bottom-right",
+  borderRadius: 10,
+  borderWidth: 1.5,
+  backgroundColor: "rgba(4, 10, 18, 0.88)",
+  borderColor: "rgba(230, 244, 255, 0.35)",
+  viewportStrokeColor: "rgba(255, 106, 61, 0.95)",
+  viewportFillColor: "rgba(255, 106, 61, 0.2)",
+  interactive: !0,
+  showThumbnail: !0,
+  maxThumbnailTiles: 16
+};
+function gt(e, t, i = 1) {
+  return typeof e != "number" || !Number.isFinite(e) ? t : Math.max(i, e);
+}
+function Tt(e) {
+  return Array.isArray(e) && e.length === 4 && Number.isFinite(e[0]) && Number.isFinite(e[1]) && Number.isFinite(e[2]) && Number.isFinite(e[3]);
+}
+function ve({
+  source: e,
+  projectorRef: t,
+  authToken: i = "",
+  options: r,
+  invalidateRef: n,
+  className: o,
+  style: a
+}) {
+  const h = O(null), u = O(null), m = O(null), T = O({
+    active: !1,
+    pointerId: null
+  }), P = O(null), F = O(!1), q = gt(
+    r?.width,
+    rt.width,
+    64
+  ), K = gt(
+    r?.height,
+    rt.height,
+    48
+  ), Q = gt(
+    r?.margin,
+    rt.margin,
+    0
+  ), at = gt(
+    r?.borderRadius,
+    rt.borderRadius,
+    0
+  ), tt = gt(
+    r?.borderWidth,
+    rt.borderWidth,
+    0
+  ), D = Math.max(
+    1,
+    Math.round(
+      gt(
+        r?.maxThumbnailTiles,
+        rt.maxThumbnailTiles,
+        1
+      )
+    )
+  ), et = r?.backgroundColor || rt.backgroundColor, Y = r?.borderColor || rt.borderColor, _ = r?.viewportStrokeColor || rt.viewportStrokeColor, nt = r?.viewportFillColor || rt.viewportFillColor, N = r?.interactive ?? rt.interactive, Z = r?.showThumbnail ?? rt.showThumbnail, E = r?.position || rt.position, H = $(() => {
+    const f = {};
+    return E === "top-left" || E === "bottom-left" ? f.left = Q : f.right = Q, E === "top-left" || E === "top-right" ? f.top = Q : f.bottom = Q, {
+      position: "absolute",
+      ...f,
+      width: q,
+      height: K,
+      borderRadius: at,
+      overflow: "hidden",
+      zIndex: 4,
+      pointerEvents: N ? "auto" : "none",
+      touchAction: "none",
+      boxShadow: "0 10px 22px rgba(0, 0, 0, 0.3)",
+      ...a
+    };
+  }, [Q, E, q, K, at, N, a]), R = S(() => {
+    const f = h.current;
+    if (!f) return;
+    const p = f.getContext("2d");
+    if (!p) return;
+    const w = q, x = K, U = Math.max(1, window.devicePixelRatio || 1), b = Math.max(1, Math.round(w * U)), V = Math.max(1, Math.round(x * U));
+    (f.width !== b || f.height !== V) && (f.width = b, f.height = V), p.setTransform(1, 0, 0, 1, 0, 0), p.clearRect(0, 0, f.width, f.height), p.setTransform(U, 0, 0, U, 0, 0), p.fillStyle = et, p.fillRect(0, 0, w, x);
+    const B = u.current;
+    B && p.drawImage(B, 0, 0, w, x), p.strokeStyle = Y, p.lineWidth = tt, p.strokeRect(
+      tt * 0.5,
+      tt * 0.5,
+      w - tt,
+      x - tt
+    );
+    const it = t.current?.getViewBounds?.(), j = Tt(it) ? it : Tt(m.current) ? m.current : null;
+    if (!j) return;
+    m.current = j;
+    const M = w / Math.max(1, e.width), X = x / Math.max(1, e.height), L = k(j[0] * M, 0, w), s = k(j[1] * X, 0, x), c = k(j[2] * M, 0, w), d = k(j[3] * X, 0, x), v = Math.max(1, c - L), A = Math.max(1, d - s);
+    p.fillStyle = nt, p.fillRect(L, s, v, A), p.strokeStyle = _, p.lineWidth = 1.5, p.strokeRect(
+      L + 0.5,
+      s + 0.5,
+      Math.max(1, v - 1),
+      Math.max(1, A - 1)
+    );
+  }, [
+    q,
+    K,
+    et,
+    Y,
+    tt,
+    t,
+    e.width,
+    e.height,
+    nt,
+    _
+  ]), W = S(() => {
+    F.current || (F.current = !0, P.current = requestAnimationFrame(() => {
+      F.current = !1, P.current = null, R();
+    }));
+  }, [R]), ct = S(
+    (f, p) => {
+      const w = h.current;
+      if (!w) return null;
+      const x = w.getBoundingClientRect();
+      if (!x.width || !x.height) return null;
+      const U = k((f - x.left) / x.width, 0, 1), b = k((p - x.top) / x.height, 0, 1);
+      return [U * e.width, b * e.height];
+    },
+    [e.width, e.height]
+  ), ht = S(
+    (f, p) => {
+      const w = t.current;
+      if (!w) return;
+      const x = w.getViewBounds?.(), U = Tt(x) ? x : Tt(m.current) ? m.current : null;
+      if (!U) return;
+      const b = Math.max(1e-6, U[2] - U[0]), V = Math.max(1e-6, U[3] - U[1]);
+      w.setViewState({
+        offsetX: f - b * 0.5,
+        offsetY: p - V * 0.5
+      }), W();
+    },
+    [t, W]
+  ), mt = S(
+    (f) => {
+      if (!N || f.button !== 0) return;
+      const p = h.current;
+      if (!p) return;
+      const w = ct(f.clientX, f.clientY);
+      w && (f.preventDefault(), f.stopPropagation(), p.setPointerCapture(f.pointerId), T.current = { active: !0, pointerId: f.pointerId }, ht(w[0], w[1]));
+    },
+    [N, ct, ht]
+  ), lt = S(
+    (f) => {
+      const p = T.current;
+      if (!p.active || p.pointerId !== f.pointerId) return;
+      const w = ct(f.clientX, f.clientY);
+      w && (f.preventDefault(), f.stopPropagation(), ht(w[0], w[1]));
+    },
+    [ct, ht]
+  ), ot = S(
+    (f) => {
+      const p = T.current;
+      if (!p.active || p.pointerId !== f.pointerId) return;
+      const w = h.current;
+      if (w && w.hasPointerCapture(f.pointerId))
+        try {
+          w.releasePointerCapture(f.pointerId);
+        } catch {
+        }
+      T.current = { active: !1, pointerId: null }, W();
+    },
+    [W]
+  );
+  return z(() => {
+    let f = !1;
+    u.current = null, W();
+    const p = 0, w = 2 ** (e.maxTierZoom - p), x = Math.ceil(e.width / w), U = Math.ceil(e.height / w), b = Math.max(1, Math.ceil(x / e.tileSize)), V = Math.max(1, Math.ceil(U / e.tileSize)), B = b * V;
+    if (!Z || B > D)
+      return;
+    const J = document.createElement("canvas");
+    J.width = Math.max(1, Math.round(q)), J.height = Math.max(1, Math.round(K));
+    const it = J.getContext("2d");
+    if (!it)
+      return;
+    it.fillStyle = et, it.fillRect(0, 0, J.width, J.height);
+    const j = [];
+    for (let M = 0; M < V; M += 1)
+      for (let X = 0; X < b; X += 1) {
+        const L = X * e.tileSize * w, s = M * e.tileSize * w, c = Math.min((X + 1) * e.tileSize, x) * w, d = Math.min((M + 1) * e.tileSize, U) * w;
+        j.push({
+          url: qt(e, p, X, M),
+          bounds: [L, s, c, d]
+        });
+      }
+    return Promise.allSettled(
+      j.map(async (M) => {
+        const X = !!i, L = await fetch(M.url, {
+          headers: X ? { Authorization: i } : void 0
+        });
+        if (!L.ok)
+          throw new Error(`HTTP ${L.status}`);
+        const s = await createImageBitmap(await L.blob());
+        return { tile: M, bitmap: s };
+      })
+    ).then((M) => {
+      if (f) {
+        for (const s of M)
+          s.status === "fulfilled" && s.value.bitmap.close();
+        return;
+      }
+      const X = J.width / Math.max(1, e.width), L = J.height / Math.max(1, e.height);
+      for (const s of M) {
+        if (s.status !== "fulfilled") continue;
+        const {
+          tile: { bounds: c },
+          bitmap: d
+        } = s.value, v = c[0] * X, A = c[1] * L, l = Math.max(1, (c[2] - c[0]) * X), g = Math.max(1, (c[3] - c[1]) * L);
+        it.drawImage(d, v, A, l, g), d.close();
+      }
+      u.current = J, W();
+    }), () => {
+      f = !0;
+    };
+  }, [
+    e,
+    i,
+    q,
+    K,
+    et,
+    Z,
+    D,
+    W
+  ]), z(() => {
+    W();
+  }, [W]), z(() => {
+    if (n)
+      return n.current = W, () => {
+        n.current === W && (n.current = null);
+      };
+  }, [n, W]), z(
+    () => () => {
+      T.current = { active: !1, pointerId: null }, P.current !== null && (cancelAnimationFrame(P.current), P.current = null), F.current = !1;
+    },
+    []
+  ), /* @__PURE__ */ ft(
+    "canvas",
+    {
+      ref: h,
+      className: o,
+      style: H,
+      onPointerDown: mt,
+      onPointerMove: lt,
+      onPointerUp: ot,
+      onPointerCancel: ot,
+      onContextMenu: (f) => {
+        f.preventDefault();
+      },
+      onWheel: (f) => {
+        f.preventDefault(), f.stopPropagation();
+      }
+    }
+  );
+}
+function Ye({
+  imageWidth: e,
+  imageHeight: t,
+  tiles: i,
+  viewState: r,
+  className: n,
+  style: o
+}) {
+  const a = O(null), h = O(null), u = $(
+    () => ({ width: "100%", height: "100%", display: "block", ...o }),
+    [o]
+  );
+  return z(() => {
+    const m = a.current;
+    if (!m)
+      return;
+    const T = new re({
+      canvas: m,
+      imageWidth: e,
+      imageHeight: t,
+      initialViewState: r
+    });
+    return h.current = T, T.setTiles(i), () => {
+      T.destroy(), h.current = null;
+    };
+  }, [e, t]), z(() => {
+    const m = h.current;
+    m && m.setTiles(i);
+  }, [i]), z(() => {
+    const m = h.current;
+    !m || !r || m.setViewState(r);
+  }, [r]), /* @__PURE__ */ ft("canvas", { ref: a, className: n, style: u });
+}
+function xe(e) {
+  if (!Array.isArray(e) || e.length < 3) return [];
+  const t = e.map(([n, o]) => [n, o]), i = t[0], r = t[t.length - 1];
+  return !i || !r ? [] : ((i[0] !== r[0] || i[1] !== r[1]) && t.push([i[0], i[1]]), t);
+}
+function Se(e) {
+  const t = [];
+  for (const i of e ?? []) {
+    const r = xe(i);
+    if (r.length < 4) continue;
+    let n = 1 / 0, o = 1 / 0, a = -1 / 0, h = -1 / 0;
+    for (const [u, m] of r)
+      u < n && (n = u), u > a && (a = u), m < o && (o = m), m > h && (h = m);
+    !Number.isFinite(n) || !Number.isFinite(o) || t.push({ ring: r, minX: n, minY: o, maxX: a, maxY: h });
+  }
+  return t;
+}
+function Pe(e, t, i) {
+  let r = !1;
+  for (let n = 0, o = i.length - 1; n < i.length; o = n, n += 1) {
+    const a = i[n][0], h = i[n][1], u = i[o][0], m = i[o][1];
+    h > t != m > t && e < (u - a) * (t - h) / (m - h || Number.EPSILON) + a && (r = !r);
+  }
+  return r;
+}
+function Ee(e, t, i) {
+  for (const r of i)
+    if (!(e < r.minX || e > r.maxX || t < r.minY || t > r.maxY) && Pe(e, t, r.ring))
+      return !0;
+  return !1;
+}
+function Re(e, t) {
+  if (!e || !e.count || !e.positions || !e.paletteIndices)
+    return null;
+  const i = Se(t ?? []);
+  if (i.length === 0)
+    return {
+      count: 0,
+      positions: new Float32Array(0),
+      paletteIndices: new Uint16Array(0)
+    };
+  const r = e.count, n = e.positions, o = e.paletteIndices, a = new Float32Array(r * 2), h = new Uint16Array(r);
+  let u = 0;
+  for (let m = 0; m < r; m += 1) {
+    const T = n[m * 2], P = n[m * 2 + 1];
+    Ee(T, P, i) && (a[u * 2] = T, a[u * 2 + 1] = P, h[u] = o[m], u += 1);
+  }
+  return {
+    count: u,
+    positions: a.subarray(0, u * 2),
+    paletteIndices: h.subarray(0, u)
+  };
+}
+class Ae {
+  constructor() {
+    this.viewportWidth = 1, this.viewportHeight = 1, this.viewState = { zoom: 1, offsetX: 0, offsetY: 0 };
+  }
+  setViewport(t, i) {
+    this.viewportWidth = Math.max(1, t), this.viewportHeight = Math.max(1, i);
+  }
+  getViewport() {
+    return { width: this.viewportWidth, height: this.viewportHeight };
+  }
+  setViewState(t) {
+    typeof t.zoom == "number" && (this.viewState.zoom = Math.max(1e-4, t.zoom)), typeof t.offsetX == "number" && (this.viewState.offsetX = t.offsetX), typeof t.offsetY == "number" && (this.viewState.offsetY = t.offsetY);
+  }
+  getViewState() {
+    return { ...this.viewState };
+  }
+  getMatrix() {
+    const t = this.viewportWidth / this.viewState.zoom, i = this.viewportHeight / this.viewState.zoom, r = 2 / t, n = -2 / i, o = -1 - this.viewState.offsetX * r, a = 1 - this.viewState.offsetY * n;
+    return new Float32Array([r, 0, 0, 0, n, 0, o, a, 1]);
+  }
+}
+class Me {
+  constructor(t, i, r = {}) {
+    this.canvas = t, this.source = i, this.onViewStateChange = r.onViewStateChange, this.onStats = r.onStats, this.authToken = r.authToken || "", this.destroyed = !1, this.frame = null, this.frameSerial = 0, this.dragging = !1, this.pointerId = null, this.lastPointerX = 0, this.lastPointerY = 0, this.interactionLocked = !1, this.cache = /* @__PURE__ */ new Map(), this.inflight = /* @__PURE__ */ new Map(), this.maxCacheTiles = 320, this.fitZoom = 1, this.minZoom = 1e-6, this.maxZoom = 1, this.currentTier = 0, this.pointCount = 0, this.pointPaletteSize = 1;
+    const n = t.getContext("webgl2", {
+      alpha: !1,
+      antialias: !1,
+      depth: !1,
+      stencil: !1,
+      powerPreference: "high-performance"
+    });
+    if (!n)
+      throw new Error("WebGL2 not supported");
+    this.gl = n, this.camera = new Ae(), this.initTileProgram(), this.initPointProgram(), this.resizeObserver = new ResizeObserver(() => this.resize()), this.resizeObserver.observe(t), this.boundPointerDown = (o) => this.onPointerDown(o), this.boundPointerMove = (o) => this.onPointerMove(o), this.boundPointerUp = (o) => this.onPointerUp(o), this.boundWheel = (o) => this.onWheel(o), this.boundDoubleClick = (o) => this.onDoubleClick(o), t.addEventListener("pointerdown", this.boundPointerDown), t.addEventListener("pointermove", this.boundPointerMove), t.addEventListener("pointerup", this.boundPointerUp), t.addEventListener("pointercancel", this.boundPointerUp), t.addEventListener("wheel", this.boundWheel, { passive: !1 }), t.addEventListener("dblclick", this.boundDoubleClick), this.fitToImage(), this.resize();
+  }
+  initTileProgram() {
+    const t = this.gl, i = `#version 300 es
+    precision highp float;
+    in vec2 aUnit;
+    in vec2 aUv;
+    uniform mat3 uCamera;
+    uniform vec4 uBounds;
+    out vec2 vUv;
+    void main() {
+      vec2 world = vec2(
+        mix(uBounds.x, uBounds.z, aUnit.x),
+        mix(uBounds.y, uBounds.w, aUnit.y)
+      );
+      vec3 clip = uCamera * vec3(world, 1.0);
+      gl_Position = vec4(clip.xy, 0.0, 1.0);
+      vUv = aUv;
+    }`, r = `#version 300 es
+    precision highp float;
+    in vec2 vUv;
+    uniform sampler2D uTexture;
+    out vec4 outColor;
+    void main() {
+      outColor = texture(uTexture, vUv);
+    }`;
+    if (this.program = Ct(t, i, r), this.uCamera = t.getUniformLocation(this.program, "uCamera"), this.uBounds = t.getUniformLocation(this.program, "uBounds"), this.uTexture = t.getUniformLocation(this.program, "uTexture"), !this.uCamera || !this.uBounds || !this.uTexture)
+      throw new Error("uniform location lookup failed");
+    if (this.vao = t.createVertexArray(), this.vbo = t.createBuffer(), !this.vao || !this.vbo)
+      throw new Error("buffer allocation failed");
+    t.bindVertexArray(this.vao), t.bindBuffer(t.ARRAY_BUFFER, this.vbo), t.bufferData(
+      t.ARRAY_BUFFER,
+      new Float32Array([
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        1,
+        1,
+        1,
+        1,
+        1
+      ]),
+      t.STATIC_DRAW
+    );
+    const n = t.getAttribLocation(this.program, "aUnit"), o = t.getAttribLocation(this.program, "aUv");
+    t.enableVertexAttribArray(n), t.enableVertexAttribArray(o), t.vertexAttribPointer(n, 2, t.FLOAT, !1, 16, 0), t.vertexAttribPointer(o, 2, t.FLOAT, !1, 16, 8), t.bindVertexArray(null), t.bindBuffer(t.ARRAY_BUFFER, null);
+  }
+  initPointProgram() {
+    const t = this.gl, i = `#version 300 es
+    precision highp float;
+    in vec2 aPosition;
+    in uint aTerm;
+    uniform mat3 uCamera;
+    uniform float uPointSize;
+    flat out uint vTerm;
+    void main() {
+      vec3 clip = uCamera * vec3(aPosition, 1.0);
+      gl_Position = vec4(clip.xy, 0.0, 1.0);
+      gl_PointSize = uPointSize;
+      vTerm = aTerm;
+    }`, r = `#version 300 es
+    precision highp float;
+    flat in uint vTerm;
+    uniform sampler2D uPalette;
+    uniform float uPaletteSize;
+    uniform float uPointSize;
+    out vec4 outColor;
+    void main() {
+      vec2 pc = gl_PointCoord * 2.0 - 1.0;
+      float r = length(pc);
+      if (r > 1.0) discard;
+
+      float idx = clamp(float(vTerm), 0.0, max(0.0, uPaletteSize - 1.0));
+      vec2 uv = vec2((idx + 0.5) / uPaletteSize, 0.5);
+      vec4 color = texture(uPalette, uv);
+      if (color.a <= 0.0) discard;
+
+      float ringWidth = clamp(3.0 / max(1.0, uPointSize), 0.12, 0.62);
+      float innerRadius = 1.0 - ringWidth;
+      float aa = 1.5 / max(1.0, uPointSize);
+
+      float outerMask = 1.0 - smoothstep(1.0 - aa, 1.0 + aa, r);
+      float innerMask = smoothstep(innerRadius - aa, innerRadius + aa, r);
+      float alpha = outerMask * innerMask * color.a;
+      if (alpha <= 0.001) discard;
+
+      outColor = vec4(color.rgb * alpha, alpha);
+    }`;
+    if (this.pointProgram = Ct(t, i, r), this.uPointCamera = t.getUniformLocation(this.pointProgram, "uCamera"), this.uPointSize = t.getUniformLocation(this.pointProgram, "uPointSize"), this.uPointPalette = t.getUniformLocation(this.pointProgram, "uPalette"), this.uPointPaletteSize = t.getUniformLocation(this.pointProgram, "uPaletteSize"), !this.uPointCamera || !this.uPointSize || !this.uPointPalette || !this.uPointPaletteSize)
+      throw new Error("point uniform location lookup failed");
+    if (this.pointVao = t.createVertexArray(), this.pointPosBuffer = t.createBuffer(), this.pointTermBuffer = t.createBuffer(), this.pointPaletteTexture = t.createTexture(), !this.pointVao || !this.pointPosBuffer || !this.pointTermBuffer || !this.pointPaletteTexture)
+      throw new Error("point buffer allocation failed");
+    t.bindVertexArray(this.pointVao), t.bindBuffer(t.ARRAY_BUFFER, this.pointPosBuffer), t.bufferData(t.ARRAY_BUFFER, 0, t.DYNAMIC_DRAW);
+    const n = t.getAttribLocation(this.pointProgram, "aPosition");
+    if (n < 0)
+      throw new Error("point position attribute not found");
+    t.enableVertexAttribArray(n), t.vertexAttribPointer(n, 2, t.FLOAT, !1, 0, 0), t.bindBuffer(t.ARRAY_BUFFER, this.pointTermBuffer), t.bufferData(t.ARRAY_BUFFER, 0, t.DYNAMIC_DRAW);
+    const o = t.getAttribLocation(this.pointProgram, "aTerm");
+    if (o < 0)
+      throw new Error("point term attribute not found");
+    t.enableVertexAttribArray(o), t.vertexAttribIPointer(o, 1, t.UNSIGNED_SHORT, 0, 0), t.bindVertexArray(null), t.bindBuffer(t.ARRAY_BUFFER, null), t.bindTexture(t.TEXTURE_2D, this.pointPaletteTexture), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.NEAREST), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.NEAREST), t.texImage2D(
+      t.TEXTURE_2D,
+      0,
+      t.RGBA,
+      1,
+      1,
+      0,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
+      new Uint8Array([160, 160, 160, 255])
+    ), t.bindTexture(t.TEXTURE_2D, null);
+  }
+  setViewState(t) {
+    const i = { ...t };
+    typeof i.zoom == "number" && (i.zoom = k(i.zoom, this.minZoom, this.maxZoom)), this.camera.setViewState(i), this.clampViewState(), this.emitViewState(), this.requestRender();
+  }
+  getViewState() {
+    return this.camera.getViewState();
+  }
+  setPointPalette(t) {
+    if (!t || !t.length) return;
+    const i = this.gl, r = Math.max(1, Math.floor(t.length / 4));
+    this.pointPaletteSize = r, i.bindTexture(i.TEXTURE_2D, this.pointPaletteTexture), i.texImage2D(i.TEXTURE_2D, 0, i.RGBA, r, 1, 0, i.RGBA, i.UNSIGNED_BYTE, t), i.bindTexture(i.TEXTURE_2D, null), this.requestRender();
+  }
+  setPointData(t) {
+    const i = this.gl;
+    if (!t || !t.count || !t.positions || !t.paletteIndices) {
+      this.pointCount = 0, this.requestRender();
+      return;
+    }
+    i.bindBuffer(i.ARRAY_BUFFER, this.pointPosBuffer), i.bufferData(i.ARRAY_BUFFER, t.positions, i.STATIC_DRAW), i.bindBuffer(i.ARRAY_BUFFER, this.pointTermBuffer), i.bufferData(i.ARRAY_BUFFER, t.paletteIndices, i.STATIC_DRAW), i.bindBuffer(i.ARRAY_BUFFER, null), this.pointCount = t.count, this.requestRender();
+  }
+  setInteractionLock(t) {
+    const i = !!t;
+    this.interactionLocked !== i && (this.interactionLocked = i, i && this.cancelDrag());
+  }
+  cancelDrag() {
+    if (this.pointerId !== null && this.canvas.hasPointerCapture(this.pointerId))
+      try {
+        this.canvas.releasePointerCapture(this.pointerId);
+      } catch {
+      }
+    this.dragging = !1, this.pointerId = null, this.canvas.classList.remove("dragging");
+  }
+  screenToWorld(t, i) {
+    const r = this.canvas.getBoundingClientRect(), n = t - r.left, o = i - r.top, a = this.camera.getViewState();
+    return [a.offsetX + n / a.zoom, a.offsetY + o / a.zoom];
+  }
+  worldToScreen(t, i) {
+    const r = this.camera.getViewState();
+    return [(t - r.offsetX) * r.zoom, (i - r.offsetY) * r.zoom];
+  }
+  getPointSizeByZoom() {
+    const t = Math.max(1e-6, this.camera.getViewState().zoom), i = this.source.maxTierZoom + Math.log2(t), r = [
+      [1, 2.6],
+      [2, 3.1],
+      [3, 3.8],
+      [4, 4.8],
+      [5, 6.1],
+      [6, 7.4],
+      [7, 8.4],
+      [8, 9],
+      [9, 11.5],
+      [10, 14.5],
+      [11, 18],
+      [12, 22]
+    ];
+    let n = r[0][1];
+    for (let a = 1; a < r.length; a += 1) {
+      const [h, u] = r[a - 1], [m, T] = r[a];
+      if (i <= h) break;
+      const P = k((i - h) / Math.max(1e-6, m - h), 0, 1);
+      n = u + (T - u) * P;
+    }
+    const o = r[r.length - 1];
+    return i > o[0] && (n += (i - o[0]) * 4), k(n, 2.2, 36);
+  }
+  fitToImage() {
+    const t = this.canvas.getBoundingClientRect(), i = Math.max(1, t.width || 1), r = Math.max(1, t.height || 1), n = Math.min(i / this.source.width, r / this.source.height), o = Number.isFinite(n) && n > 0 ? n : 1;
+    this.fitZoom = o, this.minZoom = Math.max(this.fitZoom * 0.5, 1e-6), this.maxZoom = Math.max(1, this.fitZoom * 8), this.minZoom > this.maxZoom && (this.minZoom = this.maxZoom);
+    const a = i / o, h = r / o;
+    this.camera.setViewState({
+      zoom: k(o, this.minZoom, this.maxZoom),
+      offsetX: (this.source.width - a) * 0.5,
+      offsetY: (this.source.height - h) * 0.5
+    }), this.clampViewState(), this.emitViewState(), this.requestRender();
+  }
+  zoomBy(t, i, r) {
+    const n = this.camera.getViewState(), o = k(n.zoom * t, this.minZoom, this.maxZoom);
+    if (o === n.zoom)
+      return;
+    const a = n.offsetX + i / n.zoom, h = n.offsetY + r / n.zoom;
+    this.camera.setViewState({
+      zoom: o,
+      offsetX: a - i / o,
+      offsetY: h - r / o
+    }), this.clampViewState(), this.emitViewState(), this.requestRender();
+  }
+  clampViewState() {
+    const t = this.camera.getViewState(), i = this.camera.getViewport(), r = i.width / t.zoom, n = i.height / t.zoom, o = r * 0.2, a = n * 0.2, h = -o, u = this.source.width - r + o, m = -a, T = this.source.height - n + a;
+    this.camera.setViewState({
+      offsetX: k(t.offsetX, h, u),
+      offsetY: k(t.offsetY, m, T)
+    });
+  }
+  emitViewState() {
+    typeof this.onViewStateChange == "function" && this.onViewStateChange(this.camera.getViewState());
+  }
+  selectTier() {
+    const t = Math.max(1e-6, this.camera.getViewState().zoom), i = this.source.maxTierZoom + Math.log2(t);
+    return k(Math.floor(i), 0, this.source.maxTierZoom);
+  }
+  getViewBounds() {
+    const t = this.camera.getViewState(), i = this.camera.getViewport();
+    return [
+      t.offsetX,
+      t.offsetY,
+      t.offsetX + i.width / t.zoom,
+      t.offsetY + i.height / t.zoom
+    ];
+  }
+  intersectsBounds(t, i) {
+    return !(t[2] <= i[0] || t[0] >= i[2] || t[3] <= i[1] || t[1] >= i[3]);
+  }
+  getVisibleTiles() {
+    const t = this.selectTier();
+    this.currentTier = t;
+    const i = this.camera.getViewState(), r = this.camera.getViewport(), n = Math.pow(2, this.source.maxTierZoom - t), o = Math.ceil(this.source.width / n), a = Math.ceil(this.source.height / n), h = Math.max(1, Math.ceil(o / this.source.tileSize)), u = Math.max(1, Math.ceil(a / this.source.tileSize)), m = i.offsetX, T = i.offsetY, P = i.offsetX + r.width / i.zoom, F = i.offsetY + r.height / i.zoom, q = k(Math.floor(m / n / this.source.tileSize), 0, h - 1), K = k(Math.floor((P - 1) / n / this.source.tileSize), 0, h - 1), Q = k(Math.floor(T / n / this.source.tileSize), 0, u - 1), at = k(Math.floor((F - 1) / n / this.source.tileSize), 0, u - 1);
+    if (q > K || Q > at)
+      return [];
+    const tt = (m + P) * 0.5 / n / this.source.tileSize, D = (T + F) * 0.5 / n / this.source.tileSize, et = [];
+    for (let Y = Q; Y <= at; Y += 1)
+      for (let _ = q; _ <= K; _ += 1) {
+        const nt = _ * this.source.tileSize * n, N = Y * this.source.tileSize * n, Z = Math.min((_ + 1) * this.source.tileSize, o) * n, E = Math.min((Y + 1) * this.source.tileSize, a) * n, H = _ - tt, R = Y - D;
+        et.push({
+          key: `${t}/${_}/${Y}`,
+          tier: t,
+          x: _,
+          y: Y,
+          bounds: [nt, N, Z, E],
+          distance2: H * H + R * R,
+          url: qt(this.source, t, _, Y)
+        });
+      }
+    return et.sort((Y, _) => Y.distance2 - _.distance2), et;
+  }
+  requestTile(t) {
+    if (this.cache.has(t.key) || this.inflight.has(t.key) || this.destroyed)
+      return;
+    const i = new AbortController();
+    this.inflight.set(t.key, i);
+    const r = !!this.authToken;
+    fetch(t.url, {
+      signal: i.signal,
+      headers: r ? { Authorization: this.authToken } : void 0
+    }).then((n) => {
+      if (!n.ok)
+        throw new Error(`HTTP ${n.status}`);
+      return n.blob();
+    }).then((n) => createImageBitmap(n)).then((n) => {
+      if (this.inflight.delete(t.key), this.destroyed || i.signal.aborted) {
+        n.close();
+        return;
+      }
+      const o = this.gl.createTexture();
+      if (!o) {
+        n.close();
+        return;
+      }
+      this.gl.bindTexture(this.gl.TEXTURE_2D, o), this.gl.pixelStorei(this.gl.UNPACK_FLIP_Y_WEBGL, 1), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR), this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.gl.RGBA, this.gl.UNSIGNED_BYTE, n), this.gl.bindTexture(this.gl.TEXTURE_2D, null), n.close(), this.cache.set(t.key, {
+        texture: o,
+        bounds: t.bounds,
+        tier: t.tier,
+        lastUsed: this.frameSerial
+      }), this.trimCache(), this.requestRender();
+    }).catch((n) => {
+      this.inflight.delete(t.key), !i.signal.aborted && console.warn("tile load failed", t.url, n);
+    });
+  }
+  trimCache() {
+    if (this.cache.size <= this.maxCacheTiles)
+      return;
+    const t = Array.from(this.cache.entries());
+    t.sort((r, n) => r[1].lastUsed - n[1].lastUsed);
+    const i = this.cache.size - this.maxCacheTiles;
+    for (let r = 0; r < i; r += 1) {
+      const [n, o] = t[r];
+      this.gl.deleteTexture(o.texture), this.cache.delete(n);
+    }
+  }
+  render() {
+    if (this.destroyed)
+      return;
+    this.frameSerial += 1;
+    const t = this.gl;
+    t.clearColor(0.03, 0.06, 0.1, 1), t.clear(t.COLOR_BUFFER_BIT);
+    const i = this.getVisibleTiles();
+    t.useProgram(this.program), t.bindVertexArray(this.vao), t.uniformMatrix3fv(this.uCamera, !1, this.camera.getMatrix()), t.uniform1i(this.uTexture, 0);
+    const r = this.getViewBounds(), n = [];
+    for (const [, h] of this.cache)
+      this.intersectsBounds(h.bounds, r) && n.push(h);
+    n.sort((h, u) => h.tier - u.tier);
+    for (const h of n)
+      h.lastUsed = this.frameSerial, t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, h.texture), t.uniform4f(this.uBounds, h.bounds[0], h.bounds[1], h.bounds[2], h.bounds[3]), t.drawArrays(t.TRIANGLE_STRIP, 0, 4);
+    let o = 0;
+    for (const h of i) {
+      const u = this.cache.get(h.key);
+      if (!u) {
+        this.requestTile(h);
+        continue;
+      }
+      u.lastUsed = this.frameSerial, t.activeTexture(t.TEXTURE0), t.bindTexture(t.TEXTURE_2D, u.texture), t.uniform4f(this.uBounds, u.bounds[0], u.bounds[1], u.bounds[2], u.bounds[3]), t.drawArrays(t.TRIANGLE_STRIP, 0, 4), o += 1;
+    }
+    t.bindTexture(t.TEXTURE_2D, null), t.bindVertexArray(null);
+    let a = 0;
+    this.pointCount > 0 && (t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA), t.useProgram(this.pointProgram), t.bindVertexArray(this.pointVao), t.uniformMatrix3fv(this.uPointCamera, !1, this.camera.getMatrix()), t.uniform1f(this.uPointSize, this.getPointSizeByZoom()), t.uniform1f(this.uPointPaletteSize, this.pointPaletteSize), t.uniform1i(this.uPointPalette, 1), t.activeTexture(t.TEXTURE1), t.bindTexture(t.TEXTURE_2D, this.pointPaletteTexture), t.drawArrays(t.POINTS, 0, this.pointCount), t.bindTexture(t.TEXTURE_2D, null), t.bindVertexArray(null), a = this.pointCount), typeof this.onStats == "function" && this.onStats({
+      tier: this.currentTier,
+      visible: i.length,
+      rendered: o,
+      points: a,
+      fallback: n.length,
+      cache: this.cache.size,
+      inflight: this.inflight.size
+    });
+  }
+  requestRender() {
+    this.frame !== null || this.destroyed || (this.frame = requestAnimationFrame(() => {
+      this.frame = null, this.render();
+    }));
+  }
+  resize() {
+    const t = this.canvas.getBoundingClientRect(), i = Math.max(1, t.width || this.canvas.clientWidth || 1), r = Math.max(1, t.height || this.canvas.clientHeight || 1), n = Math.max(1, window.devicePixelRatio || 1), o = Math.max(1, Math.round(i * n)), a = Math.max(1, Math.round(r * n));
+    (this.canvas.width !== o || this.canvas.height !== a) && (this.canvas.width = o, this.canvas.height = a), this.camera.setViewport(i, r), this.gl.viewport(0, 0, o, a), this.requestRender();
+  }
+  onPointerDown(t) {
+    this.interactionLocked || (this.dragging = !0, this.pointerId = t.pointerId, this.lastPointerX = t.clientX, this.lastPointerY = t.clientY, this.canvas.classList.add("dragging"), this.canvas.setPointerCapture(t.pointerId));
+  }
+  onPointerMove(t) {
+    if (this.interactionLocked || !this.dragging || t.pointerId !== this.pointerId)
+      return;
+    const i = t.clientX - this.lastPointerX, r = t.clientY - this.lastPointerY;
+    this.lastPointerX = t.clientX, this.lastPointerY = t.clientY;
+    const n = this.camera.getViewState();
+    this.camera.setViewState({
+      offsetX: n.offsetX - i / n.zoom,
+      offsetY: n.offsetY - r / n.zoom
+    }), this.clampViewState(), this.emitViewState(), this.requestRender();
+  }
+  onPointerUp(t) {
+    this.interactionLocked || t.pointerId === this.pointerId && (this.dragging = !1, this.pointerId = null, this.canvas.classList.remove("dragging"));
+  }
+  onWheel(t) {
+    if (this.interactionLocked) {
+      t.preventDefault();
+      return;
+    }
+    t.preventDefault();
+    const i = this.canvas.getBoundingClientRect(), r = t.clientX - i.left, n = t.clientY - i.top, o = t.deltaY < 0 ? 1.12 : 0.89;
+    this.zoomBy(o, r, n);
+  }
+  onDoubleClick(t) {
+    if (this.interactionLocked)
+      return;
+    const i = this.canvas.getBoundingClientRect(), r = t.clientX - i.left, n = t.clientY - i.top;
+    this.zoomBy(t.shiftKey ? 0.8 : 1.25, r, n);
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0, this.frame !== null && (cancelAnimationFrame(this.frame), this.frame = null), this.resizeObserver.disconnect(), this.canvas.removeEventListener("pointerdown", this.boundPointerDown), this.canvas.removeEventListener("pointermove", this.boundPointerMove), this.canvas.removeEventListener("pointerup", this.boundPointerUp), this.canvas.removeEventListener("pointercancel", this.boundPointerUp), this.canvas.removeEventListener("wheel", this.boundWheel), this.canvas.removeEventListener("dblclick", this.boundDoubleClick), this.cancelDrag();
+      for (const [, t] of this.inflight)
+        t.abort();
+      this.inflight.clear();
+      for (const [, t] of this.cache)
+        this.gl.deleteTexture(t.texture);
+      this.cache.clear(), this.gl.deleteBuffer(this.vbo), this.gl.deleteVertexArray(this.vao), this.gl.deleteProgram(this.program), this.gl.deleteBuffer(this.pointPosBuffer), this.gl.deleteBuffer(this.pointTermBuffer), this.gl.deleteTexture(this.pointPaletteTexture), this.gl.deleteVertexArray(this.pointVao), this.gl.deleteProgram(this.pointProgram);
+    }
+  }
+}
+const Yt = [], Ie = [];
+function At(e, t) {
+  return e.id ?? t;
+}
+function Ce(e, t) {
+  if (!Array.isArray(t) || t.length < 3) return !1;
+  const [i, r] = e;
+  let n = !1;
+  for (let o = 0, a = t.length - 1; o < t.length; a = o++) {
+    const [h, u] = t[o], [m, T] = t[a];
+    u > r != T > r && i < (m - h) * (r - u) / Math.max(1e-12, T - u) + h && (n = !n);
+  }
+  return n;
+}
+function Vt(e, t) {
+  for (let i = t.length - 1; i >= 0; i -= 1) {
+    const r = t[i];
+    if (r?.coordinates?.length && Ce(e, r.coordinates))
+      return {
+        region: r,
+        regionIndex: i,
+        regionId: At(r, i)
+      };
+  }
+  return null;
+}
+function Ve({
+  source: e,
+  viewState: t,
+  onViewStateChange: i,
+  onStats: r,
+  fitNonce: n = 0,
+  authToken: o = "",
+  pointData: a = null,
+  pointPalette: h = null,
+  roiRegions: u,
+  roiPolygons: m,
+  clipPointsToRois: T = !1,
+  interactionLock: P = !1,
+  drawTool: F = "cursor",
+  stampOptions: q,
+  regionStrokeStyle: K,
+  regionStrokeHoverStyle: Q,
+  regionStrokeActiveStyle: at,
+  regionLabelStyle: tt,
+  onRegionHover: D,
+  onRegionClick: et,
+  onActiveRegionChange: Y,
+  onDrawComplete: _,
+  showOverviewMap: nt = !1,
+  overviewMapOptions: N,
+  className: Z,
+  style: E
+}) {
+  const H = O(null), R = O(null), W = O(null), ct = O(null), ht = O(i), [mt, lt] = xt(!0), [ot, f] = xt(null), [p, w] = xt(
+    null
+  ), x = O(null), U = u ?? Yt, b = m ?? Ie, V = $(
+    () => ({ position: "relative", width: "100%", height: "100%", ...E }),
+    [E]
+  ), B = $(() => U.length > 0 ? U : b.length === 0 ? Yt : b.map((l, g) => ({
+    id: g,
+    coordinates: l
+  })), [U, b]), J = $(
+    () => B.map((l) => l.coordinates),
+    [B]
+  ), it = $(() => T ? Re(a, J) : a, [T, a, J]);
+  $(() => {
+    const l = Number(N?.width ?? 220);
+    return Number.isFinite(l) ? Math.max(64, l) : 220;
+  }, [N?.width]);
+  const j = $(() => {
+    const l = Number(N?.height ?? 140);
+    return Number.isFinite(l) ? Math.max(48, l) : 140;
+  }, [N?.height]), M = $(() => {
+    const l = Number(N?.margin ?? 16);
+    return Number.isFinite(l) ? Math.max(0, l) : 16;
+  }, [N?.margin]), X = N?.position || "bottom-right", L = S(
+    (l) => {
+      w((g) => String(g) === String(l) ? g : (Y?.(l), l));
+    },
+    [Y]
+  );
+  z(() => {
+    ht.current = i;
+  }, [i]), z(() => {
+    !(p === null ? !0 : B.some(
+      (C, G) => String(At(C, G)) === String(p)
+    )) && p !== null && L(null);
+    const g = x.current;
+    !(g === null ? !0 : B.some(
+      (C, G) => String(At(C, G)) === String(g)
+    )) && g !== null && (x.current = null, f(null), D?.({
+      region: null,
+      regionId: null,
+      regionIndex: -1,
+      coordinate: null
+    }));
+  }, [B, p, D, L]);
+  const s = S((l) => {
+    const g = ht.current;
+    g && g(l), W.current?.(), ct.current?.();
+  }, []);
+  z(() => {
+    if (!nt) {
+      lt(!1);
+      return;
+    }
+    lt(!0);
+  }, [nt, e?.id]), z(() => {
+    F !== "cursor" && x.current !== null && (x.current = null, f(null), D?.({
+      region: null,
+      regionId: null,
+      regionIndex: -1,
+      coordinate: null
+    }));
+  }, [F, D]);
+  const c = S(
+    (l, g) => {
+      const I = R.current;
+      if (!I) return null;
+      const C = I.screenToWorld(l, g);
+      if (!Array.isArray(C) || C.length < 2) return null;
+      const G = Number(C[0]), pt = Number(C[1]);
+      return !Number.isFinite(G) || !Number.isFinite(pt) ? null : [G, pt];
+    },
+    []
+  ), d = S(
+    (l) => {
+      if (F !== "cursor") return;
+      if (l.target !== H.current) {
+        x.current !== null && (x.current = null, f(null), D?.({
+          region: null,
+          regionId: null,
+          regionIndex: -1,
+          coordinate: null
+        }));
+        return;
+      }
+      if (!B.length) return;
+      const g = c(l.clientX, l.clientY);
+      if (!g) return;
+      const I = Vt(g, B), C = I?.regionId ?? null, G = x.current;
+      String(G) !== String(C) && (x.current = C, f(C), D?.({
+        region: I?.region ?? null,
+        regionId: C,
+        regionIndex: I?.regionIndex ?? -1,
+        coordinate: g
+      }));
+    },
+    [F, B, c, D]
+  ), v = S(() => {
+    x.current !== null && (x.current = null, f(null), D?.({
+      region: null,
+      regionId: null,
+      regionIndex: -1,
+      coordinate: null
+    }));
+  }, [D]), A = S(
+    (l) => {
+      if (F !== "cursor" || l.target !== H.current) return;
+      if (!B.length) {
+        L(null);
+        return;
+      }
+      const g = c(l.clientX, l.clientY);
+      if (!g) return;
+      const I = Vt(g, B);
+      if (!I) {
+        L(null);
+        return;
+      }
+      let C = I.regionId;
+      p !== null && (C = String(p) === String(I.regionId) ? p : null), L(C), et?.({
+        region: I.region,
+        regionId: I.regionId,
+        regionIndex: I.regionIndex,
+        coordinate: g
+      });
+    },
+    [
+      F,
+      B,
+      c,
+      et,
+      p,
+      L
+    ]
+  );
+  return z(() => {
+    const l = H.current;
+    if (!l || !e)
+      return;
+    const g = new Me(l, e, {
+      onViewStateChange: s,
+      onStats: r,
+      authToken: o
+    });
+    return R.current = g, t && g.setViewState(t), g.setInteractionLock(P), () => {
+      g.destroy(), R.current = null;
+    };
+  }, [e, r, o, s]), z(() => {
+    const l = R.current;
+    !l || !t || l.setViewState(t);
+  }, [t]), z(() => {
+    const l = R.current;
+    l && l.fitToImage();
+  }, [n]), z(() => {
+    const l = R.current;
+    !l || !h || l.setPointPalette(h);
+  }, [h]), z(() => {
+    const l = R.current;
+    l && l.setPointData(it);
+  }, [it]), z(() => {
+    const l = R.current;
+    l && l.setInteractionLock(P);
+  }, [P]), /* @__PURE__ */ Mt(
+    "div",
+    {
+      className: Z,
+      style: V,
+      onPointerMove: d,
+      onPointerLeave: v,
+      onClick: A,
+      children: [
+        /* @__PURE__ */ ft(
+          "canvas",
+          {
+            ref: H,
+            className: "wsi-render-canvas",
+            style: {
+              position: "absolute",
+              inset: 0,
+              zIndex: 1,
+              width: "100%",
+              height: "100%",
+              display: "block",
+              touchAction: "none",
+              cursor: F === "cursor" && ot !== null ? "pointer" : P ? "crosshair" : "grab"
+            }
+          }
+        ),
+        e ? /* @__PURE__ */ ft(
+          Te,
+          {
+            tool: F,
+            enabled: F !== "cursor",
+            imageWidth: e.width,
+            imageHeight: e.height,
+            imageMpp: e.mpp,
+            imageZoom: e.maxTierZoom,
+            stampOptions: q,
+            projectorRef: R,
+            viewStateSignal: t,
+            persistedRegions: B,
+            regionStrokeStyle: K,
+            regionStrokeHoverStyle: Q,
+            regionStrokeActiveStyle: at,
+            hoveredRegionId: ot,
+            activeRegionId: p,
+            regionLabelStyle: tt,
+            invalidateRef: W,
+            onDrawComplete: _
+          }
+        ) : null,
+        e && nt ? mt ? /* @__PURE__ */ Mt(Kt, { children: [
+          /* @__PURE__ */ ft(
+            ve,
+            {
+              source: e,
+              projectorRef: R,
+              authToken: o,
+              options: N,
+              invalidateRef: ct
+            }
+          ),
+          /* @__PURE__ */ ft(
+            "button",
+            {
+              type: "button",
+              "aria-label": "Hide overview map",
+              onClick: () => lt(!1),
+              style: {
+                position: "absolute",
+                zIndex: 6,
+                ...X.includes("left") ? { left: M } : { right: M },
+                ...X.includes("top") ? { top: M + j + 8 } : { bottom: M + j + 8 },
+                width: 20,
+                height: 20,
+                borderRadius: 999,
+                border: "1px solid rgba(255,255,255,0.4)",
+                background: "rgba(8, 14, 22, 0.9)",
+                color: "#fff",
+                fontSize: 13,
+                lineHeight: 1,
+                cursor: "pointer",
+                padding: 0
+              },
+              children: "×"
+            }
+          )
+        ] }) : /* @__PURE__ */ ft(
+          "button",
+          {
+            type: "button",
+            "aria-label": "Show overview map",
+            onClick: () => lt(!0),
+            style: {
+              position: "absolute",
+              zIndex: 6,
+              ...X.includes("left") ? { left: M } : { right: M },
+              ...X.includes("top") ? { top: M } : { bottom: M },
+              height: 24,
+              minWidth: 40,
+              borderRadius: 999,
+              border: "1px solid rgba(255,255,255,0.45)",
+              background: "rgba(8, 14, 22, 0.9)",
+              color: "#dff8ff",
+              fontSize: 11,
+              fontWeight: 700,
+              cursor: "pointer",
+              padding: "0 8px"
+            },
+            children: "Map"
+          }
+        ) : null
+      ]
+    }
+  );
+}
+export {
+  Nt as DEFAULT_POINT_COLOR,
+  Te as DrawLayer,
+  re as M1TileRenderer,
+  ve as OverviewMap,
+  Ye as TileViewerCanvas,
+  Me as WsiTileRenderer,
+  Ve as WsiViewerCanvas,
+  Le as buildTermPalette,
+  Ue as calcScaleLength,
+  Wt as calcScaleResolution,
+  k as clamp,
+  dt as closeRing,
+  Ft as createCircle,
+  zt as createRectangle,
+  Re as filterPointDataByPolygons,
+  ne as hexToRgba,
+  Be as isSameViewState,
+  De as normalizeImageInfo,
+  Xe as toBearerToken,
+  qt as toTileUrl
+};
+//# sourceMappingURL=index.js.map