@annotorious/react 3.0.0-rc.21 → 3.0.0-rc.4

package/dist/annotorious-react.es18.js

@@ -1,5 +1,3896 @@
-var e = { exports: {} };
+function U() {
+}
+function Ke(t, e) {
+  for (const n in e)
+    t[n] = e[n];
+  return t;
+}
+function Oe(t) {
+  return t();
+}
+function le() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function it(t) {
+  t.forEach(Oe);
+}
+function H(t) {
+  return typeof t == "function";
+}
+function K(t, e) {
+  return t != t ? e == e : t !== e || t && typeof t == "object" || typeof t == "function";
+}
+function Je(t) {
+  return Object.keys(t).length === 0;
+}
+function Ve(t, ...e) {
+  if (t == null)
+    return U;
+  const n = t.subscribe(...e);
+  return n.unsubscribe ? () => n.unsubscribe() : n;
+}
+function de(t, e, n) {
+  t.$$.on_destroy.push(Ve(e, n));
+}
+function Qe(t, e, n, o) {
+  if (t) {
+    const r = ke(t, e, n, o);
+    return t[0](r);
+  }
+}
+function ke(t, e, n, o) {
+  return t[1] && o ? Ke(n.ctx.slice(), t[1](o(e))) : n.ctx;
+}
+function Ze(t, e, n, o) {
+  if (t[2] && o) {
+    const r = t[2](o(n));
+    if (e.dirty === void 0)
+      return r;
+    if (typeof r == "object") {
+      const i = [], a = Math.max(e.dirty.length, r.length);
+      for (let s = 0; s < a; s += 1)
+        i[s] = e.dirty[s] | r[s];
+      return i;
+    }
+    return e.dirty | r;
+  }
+  return e.dirty;
+}
+function tn(t, e, n, o, r, i) {
+  if (r) {
+    const a = ke(e, n, o, i);
+    t.p(a, r);
+  }
+}
+function en(t) {
+  if (t.ctx.length > 32) {
+    const e = [], n = t.ctx.length / 32;
+    for (let o = 0; o < n; o++)
+      e[o] = -1;
+    return e;
+  }
+  return -1;
+}
+function dt(t, e) {
+  t.appendChild(e);
+}
+function B(t, e, n) {
+  t.insertBefore(e, n || null);
+}
+function L(t) {
+  t.parentNode && t.parentNode.removeChild(t);
+}
+function oe(t, e) {
+  for (let n = 0; n < t.length; n += 1)
+    t[n] && t[n].d(e);
+}
+function O(t) {
+  return document.createElementNS("http://www.w3.org/2000/svg", t);
+}
+function Ne(t) {
+  return document.createTextNode(t);
+}
+function tt() {
+  return Ne(" ");
+}
+function at() {
+  return Ne("");
+}
+function R(t, e, n, o) {
+  return t.addEventListener(e, n, o), () => t.removeEventListener(e, n, o);
+}
+function u(t, e, n) {
+  n == null ? t.removeAttribute(e) : t.getAttribute(e) !== n && t.setAttribute(e, n);
+}
+function nn(t) {
+  return Array.from(t.childNodes);
+}
+function ce(t, e, n) {
+  t.classList[n ? "add" : "remove"](e);
+}
+function on(t, e, { bubbles: n = !1, cancelable: o = !1 } = {}) {
+  const r = document.createEvent("CustomEvent");
+  return r.initCustomEvent(t, n, o, e), r;
+}
+let Xt;
+function Bt(t) {
+  Xt = t;
+}
+function De() {
+  if (!Xt)
+    throw new Error("Function called outside component initialization");
+  return Xt;
+}
+function It(t) {
+  De().$$.on_mount.push(t);
+}
+function At() {
+  const t = De();
+  return (e, n, { cancelable: o = !1 } = {}) => {
+    const r = t.$$.callbacks[e];
+    if (r) {
+      const i = on(e, n, { cancelable: o });
+      return r.slice().forEach((a) => {
+        a.call(t, i);
+      }), !i.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function vt(t, e) {
+  const n = t.$$.callbacks[e.type];
+  n && n.slice().forEach((o) => o.call(this, e));
+}
+const xt = [], Dt = [];
+let Et = [];
+const ue = [], rn = /* @__PURE__ */ Promise.resolve();
+let te = !1;
+function an() {
+  te || (te = !0, rn.then(Ge));
+}
+function ee(t) {
+  Et.push(t);
+}
+const Rt = /* @__PURE__ */ new Set();
+let yt = 0;
+function Ge() {
+  if (yt !== 0)
+    return;
+  const t = Xt;
+  do {
+    try {
+      for (; yt < xt.length; ) {
+        const e = xt[yt];
+        yt++, Bt(e), sn(e.$$);
+      }
+    } catch (e) {
+      throw xt.length = 0, yt = 0, e;
+    }
+    for (Bt(null), xt.length = 0, yt = 0; Dt.length; )
+      Dt.pop()();
+    for (let e = 0; e < Et.length; e += 1) {
+      const n = Et[e];
+      Rt.has(n) || (Rt.add(n), n());
+    }
+    Et.length = 0;
+  } while (xt.length);
+  for (; ue.length; )
+    ue.pop()();
+  te = !1, Rt.clear(), Bt(t);
+}
+function sn(t) {
+  if (t.fragment !== null) {
+    t.update(), it(t.before_update);
+    const e = t.dirty;
+    t.dirty = [-1], t.fragment && t.fragment.p(t.ctx, e), t.after_update.forEach(ee);
+  }
+}
+function ln(t) {
+  const e = [], n = [];
+  Et.forEach((o) => t.indexOf(o) === -1 ? e.push(o) : n.push(o)), n.forEach((o) => o()), Et = e;
+}
+const Nt = /* @__PURE__ */ new Set();
+let ht;
+function ot() {
+  ht = {
+    r: 0,
+    c: [],
+    p: ht
+    // parent group
+  };
+}
+function rt() {
+  ht.r || it(ht.c), ht = ht.p;
+}
+function V(t, e) {
+  t && t.i && (Nt.delete(t), t.i(e));
+}
+function k(t, e, n, o) {
+  if (t && t.o) {
+    if (Nt.has(t))
+      return;
+    Nt.add(t), ht.c.push(() => {
+      Nt.delete(t), o && (n && t.d(1), o());
+    }), t.o(e);
+  } else
+    o && o();
+}
+function ft(t) {
+  t && t.c();
+}
+function ct(t, e, n, o) {
+  const { fragment: r, after_update: i } = t.$$;
+  r && r.m(e, n), o || ee(() => {
+    const a = t.$$.on_mount.map(Oe).filter(H);
+    t.$$.on_destroy ? t.$$.on_destroy.push(...a) : it(a), t.$$.on_mount = [];
+  }), i.forEach(ee);
+}
+function ut(t, e) {
+  const n = t.$$;
+  n.fragment !== null && (ln(n.after_update), it(n.on_destroy), n.fragment && n.fragment.d(e), n.on_destroy = n.fragment = null, n.ctx = []);
+}
+function dn(t, e) {
+  t.$$.dirty[0] === -1 && (xt.push(t), an(), t.$$.dirty.fill(0)), t.$$.dirty[e / 31 | 0] |= 1 << e % 31;
+}
+function et(t, e, n, o, r, i, a, s = [-1]) {
+  const l = Xt;
+  Bt(t);
+  const d = t.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props: i,
+    update: U,
+    not_equal: r,
+    bound: le(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(e.context || (l ? l.$$.context : [])),
+    // everything else
+    callbacks: le(),
+    dirty: s,
+    skip_bound: !1,
+    root: e.target || l.$$.root
+  };
+  a && a(d.root);
+  let p = !1;
+  if (d.ctx = n ? n(t, e.props || {}, (c, f, ...h) => {
+    const m = h.length ? h[0] : f;
+    return d.ctx && r(d.ctx[c], d.ctx[c] = m) && (!d.skip_bound && d.bound[c] && d.bound[c](m), p && dn(t, c)), f;
+  }) : [], d.update(), p = !0, it(d.before_update), d.fragment = o ? o(d.ctx) : !1, e.target) {
+    if (e.hydrate) {
+      const c = nn(e.target);
+      d.fragment && d.fragment.l(c), c.forEach(L);
+    } else
+      d.fragment && d.fragment.c();
+    e.intro && V(t.$$.fragment), ct(t, e.target, e.anchor, e.customElement), Ge();
+  }
+  Bt(l);
+}
+class nt {
+  $destroy() {
+    ut(this, 1), this.$destroy = U;
+  }
+  $on(e, n) {
+    if (!H(n))
+      return U;
+    const o = this.$$.callbacks[e] || (this.$$.callbacks[e] = []);
+    return o.push(n), () => {
+      const r = o.indexOf(n);
+      r !== -1 && o.splice(r, 1);
+    };
+  }
+  $set(e) {
+    this.$$set && !Je(e) && (this.$$.skip_bound = !0, this.$$set(e), this.$$.skip_bound = !1);
+  }
+}
+var F = /* @__PURE__ */ ((t) => (t.ELLIPSE = "ELLIPSE", t.POLYGON = "POLYGON", t.RECTANGLE = "RECTANGLE", t))(F || {});
+const re = {}, ie = (t, e) => re[t] = e, ne = (t) => re[t.type].area(t), cn = (t, e, n) => re[t.type].intersects(t, e, n), Gt = (t) => {
+  let e = 1 / 0, n = 1 / 0, o = -1 / 0, r = -1 / 0;
+  return t.forEach(([i, a]) => {
+    e = Math.min(e, i), n = Math.min(n, a), o = Math.max(o, i), r = Math.max(r, a);
+  }), { minX: e, minY: n, maxX: o, maxY: r };
+}, un = {
+  area: (t) => Math.PI * t.geometry.rx * t.geometry.ry,
+  intersects: (t, e, n) => {
+    const { cx: o, cy: r, rx: i, ry: a } = t.geometry, s = 0, l = Math.cos(s), d = Math.sin(s), p = e - o, c = n - r, f = l * p + d * c, h = d * p - l * c;
+    return f * f / (i * i) + h * h / (a * a) <= 1;
+  }
+};
+ie(F.ELLIPSE, un);
+const hn = {
+  area: (t) => {
+    const { points: e } = t.geometry;
+    let n = 0, o = e.length - 1;
+    for (let r = 0; r < e.length; r++)
+      n += (e[o][0] + e[r][0]) * (e[o][1] - e[r][1]), o = r;
+    return Math.abs(0.5 * n);
+  },
+  intersects: (t, e, n) => {
+    const { points: o } = t.geometry;
+    let r = !1;
+    for (let i = 0, a = o.length - 1; i < o.length; a = i++) {
+      const s = o[i][0], l = o[i][1], d = o[a][0], p = o[a][1];
+      l > n != p > n && e < (d - s) * (n - l) / (p - l) + s && (r = !r);
+    }
+    return r;
+  }
+};
+ie(F.POLYGON, hn);
+const pn = {
+  area: (t) => t.geometry.w * t.geometry.h,
+  intersects: (t, e, n) => e >= t.geometry.x && e <= t.geometry.x + t.geometry.w && n >= t.geometry.y && n <= t.geometry.y + t.geometry.h
+};
+ie(F.RECTANGLE, pn);
+const fn = (t, e = !1) => {
+  const n = typeof t == "string" ? t : t.value, o = /^(xywh)=(pixel|percent)?:?(.+?),(.+?),(.+?),(.+)*/g, r = [...n.matchAll(o)][0], [i, a, s, l, d, p, c] = r;
+  if (a !== "xywh")
+    throw new Error("Unsupported MediaFragment: " + n);
+  if (s && s !== "pixel")
+    throw new Error(`Unsupported MediaFragment unit: ${s}`);
+  const [f, h, m, x] = [l, d, p, c].map(parseFloat);
+  return {
+    type: F.RECTANGLE,
+    geometry: {
+      x: f,
+      y: h,
+      w: m,
+      h: x,
+      bounds: {
+        minX: f,
+        minY: e ? h - x : h,
+        maxX: f + m,
+        maxY: e ? h : h + x
+      }
+    }
+  };
+}, gn = (t) => {
+  const { x: e, y: n, w: o, h: r } = t;
+  return {
+    type: "FragmentSelector",
+    conformsTo: "http://www.w3.org/TR/media-frags/",
+    value: `xywh=pixel:${e},${n},${o},${r}`
+  };
+}, Ue = "http://www.w3.org/2000/svg", he = (t) => {
+  const e = (o) => {
+    Array.from(o.attributes).forEach((r) => {
+      r.name.startsWith("on") && o.removeAttribute(r.name);
+    });
+  }, n = t.getElementsByTagName("script");
+  return Array.from(n).reverse().forEach((o) => o.parentNode.removeChild(o)), Array.from(t.querySelectorAll("*")).forEach(e), t;
+}, mn = (t) => {
+  const e = new XMLSerializer().serializeToString(t.documentElement).replace("<svg>", `<svg xmlns="${Ue}">`);
+  return new DOMParser().parseFromString(e, "image/svg+xml").documentElement;
+}, yn = (t) => {
+  const e = new DOMParser().parseFromString(t, "image/svg+xml"), n = e.lookupPrefix(Ue), o = e.lookupNamespaceURI(null);
+  return n || o ? he(e).firstChild : he(mn(e)).firstChild;
+}, $n = (t) => {
+  const [e, n, o] = t.match(/(<polygon points=["|'])([^("|')]*)/) || [];
+  if (!o)
+    return;
+  const r = o.split(" ").map((i) => i.split(",").map(parseFloat));
+  return {
+    type: F.POLYGON,
+    geometry: {
+      points: r,
+      bounds: Gt(r)
+    }
+  };
+}, wn = (t) => {
+  const e = yn(t), n = parseFloat(e.getAttribute("cx")), o = parseFloat(e.getAttribute("cy")), r = parseFloat(e.getAttribute("rx")), i = parseFloat(e.getAttribute("ry")), a = {
+    minX: n - r,
+    minY: o - i,
+    maxX: n + r,
+    maxY: o + i
+  };
+  return {
+    type: F.ELLIPSE,
+    geometry: {
+      cx: n,
+      cy: o,
+      rx: r,
+      ry: i,
+      bounds: a
+    }
+  };
+}, xn = (t) => {
+  const e = typeof t == "string" ? t : t.value;
+  if (e.includes("<polygon points="))
+    return $n(e);
+  if (e.includes("<ellipse "))
+    return wn(e);
+}, bn = (t) => {
+  let e;
+  if (t.type === F.POLYGON) {
+    const n = t.geometry, { points: o } = n;
+    e = `<svg><polygon points="${o.map((r) => r.join(",")).join(" ")}" /></svg>`;
+  } else if (t.type === F.ELLIPSE) {
+    const n = t.geometry;
+    e = `<svg><ellipse cx="${n.cx}" cy="${n.cy}" rx="${n.rx}" ry="${n.ry}" /></svg>`;
+  }
+  if (e)
+    return { type: "SvgSelector", value: e };
+  throw `Unsupported shape type: ${t.type}`;
+};
+let Ot;
+const vn = new Uint8Array(16);
+function En() {
+  if (!Ot && (Ot = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !Ot))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return Ot(vn);
+}
+const z = [];
+for (let t = 0; t < 256; ++t)
+  z.push((t + 256).toString(16).slice(1));
+function An(t, e = 0) {
+  return z[t[e + 0]] + z[t[e + 1]] + z[t[e + 2]] + z[t[e + 3]] + "-" + z[t[e + 4]] + z[t[e + 5]] + "-" + z[t[e + 6]] + z[t[e + 7]] + "-" + z[t[e + 8]] + z[t[e + 9]] + "-" + z[t[e + 10]] + z[t[e + 11]] + z[t[e + 12]] + z[t[e + 13]] + z[t[e + 14]] + z[t[e + 15]];
+}
+const Tn = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), pe = {
+  randomUUID: Tn
+};
+function Fe(t, e, n) {
+  if (pe.randomUUID && !e && !t)
+    return pe.randomUUID();
+  t = t || {};
+  const o = t.random || (t.rng || En)();
+  if (o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, e) {
+    n = n || 0;
+    for (let r = 0; r < 16; ++r)
+      e[n + r] = o[r];
+    return e;
+  }
+  return An(o);
+}
+var fe = Object.prototype.hasOwnProperty;
+function pt(t, e) {
+  var n, o;
+  if (t === e)
+    return !0;
+  if (t && e && (n = t.constructor) === e.constructor) {
+    if (n === Date)
+      return t.getTime() === e.getTime();
+    if (n === RegExp)
+      return t.toString() === e.toString();
+    if (n === Array) {
+      if ((o = t.length) === e.length)
+        for (; o-- && pt(t[o], e[o]); )
+          ;
+      return o === -1;
+    }
+    if (!n || typeof t == "object") {
+      o = 0;
+      for (n in t)
+        if (fe.call(t, n) && ++o && !fe.call(e, n) || !(n in e) || !pt(t[n], e[n]))
+          return !1;
+      return Object.keys(e).length === o;
+    }
+  }
+  return t !== t && e !== e;
+}
+const $t = [];
+function Ut(t, e = U) {
+  let n;
+  const o = /* @__PURE__ */ new Set();
+  function r(s) {
+    if (K(t, s) && (t = s, n)) {
+      const l = !$t.length;
+      for (const d of o)
+        d[1](), $t.push(d, t);
+      if (l) {
+        for (let d = 0; d < $t.length; d += 2)
+          $t[d][0]($t[d + 1]);
+        $t.length = 0;
+      }
+    }
+  }
+  function i(s) {
+    r(s(t));
+  }
+  function a(s, l = U) {
+    const d = [s, l];
+    return o.add(d), o.size === 1 && (n = e(r) || U), s(t), () => {
+      o.delete(d), o.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: r, update: i, subscribe: a };
+}
+const Sn = (t) => {
+  const { subscribe: e, set: n } = Ut(null);
+  let o = null;
+  return e((r) => o = r), t.observe(({ changes: r }) => {
+    if (o) {
+      r.deleted.some((a) => a.id === o) && n(null);
+      const i = r.updated.find(({ oldValue: a }) => a.id === o);
+      i && n(i.newValue.id);
+    }
+  }), {
+    get current() {
+      return o;
+    },
+    subscribe: e,
+    set: n
+  };
+};
+var He = /* @__PURE__ */ ((t) => (t.EDIT = "EDIT", t.SELECT = "SELECT", t.NONE = "NONE", t))(He || {});
+const qt = { selected: [] }, Mn = (t, e = "EDIT") => {
+  const { subscribe: n, set: o } = Ut(qt);
+  let r = qt;
+  n((c) => r = c);
+  const i = () => o(qt), a = () => {
+    var c;
+    return ((c = r.selected) == null ? void 0 : c.length) === 0;
+  }, s = (c) => {
+    if (r.selected.length === 0)
+      return !1;
+    const f = typeof c == "string" ? c : c.id;
+    return r.selected.some((h) => h.id === f);
+  }, l = (c, f) => {
+    const h = t.getAnnotation(c);
+    if (h) {
+      const m = Ln(h, e);
+      o(m === "EDIT" ? { selected: [{ id: c, editable: !0 }], pointerEvent: f } : m === "SELECT" ? { selected: [{ id: c }], pointerEvent: f } : { selected: [], pointerEvent: f });
+    } else
+      console.warn("Invalid selection: " + c);
+  }, d = (c, f = !0) => {
+    const h = Array.isArray(c) ? c : [c], m = h.map((x) => t.getAnnotation(x)).filter((x) => x);
+    o({ selected: m.map(({ id: x }) => ({ id: x, editable: f })) }), m.length !== h.length && console.warn("Invalid selection", c);
+  }, p = (c) => {
+    if (r.selected.length === 0)
+      return !1;
+    const { selected: f } = r;
+    f.filter(({ id: h }) => c.includes(h)).length > 0 && o({ selected: f.filter(({ id: h }) => !c.includes(h)) });
+  };
+  return t.observe(({ changes: c }) => p(c.deleted.map((f) => f.id))), {
+    clear: i,
+    clickSelect: l,
+    get selected() {
+      return r ? [...r.selected] : null;
+    },
+    get pointerEvent() {
+      return r ? r.pointerEvent : null;
+    },
+    isEmpty: a,
+    isSelected: s,
+    setSelected: d,
+    subscribe: n
+  };
+}, Ln = (t, e) => typeof e == "function" ? e(t) || "EDIT" : e || "EDIT", Bn = (t, e) => {
+  const n = new Set(t.bodies.map((o) => o.id));
+  return e.bodies.filter((o) => !n.has(o.id));
+}, Xn = (t, e) => {
+  const n = new Set(e.bodies.map((o) => o.id));
+  return t.bodies.filter((o) => !n.has(o.id));
+}, In = (t, e) => e.bodies.map((n) => {
+  const o = t.bodies.find((r) => r.id === n.id);
+  return { newBody: n, oldBody: o && !pt(o, n) ? o : void 0 };
+}).filter(({ oldBody: n }) => n), Yn = (t, e) => !pt(t.target, e.target), je = (t, e) => {
+  const n = Bn(t, e), o = Xn(t, e), r = In(t, e);
+  return {
+    oldValue: t,
+    newValue: e,
+    bodiesCreated: n.length > 0 ? n : void 0,
+    bodiesDeleted: o.length > 0 ? o : void 0,
+    bodiesUpdated: r.length > 0 ? r : void 0,
+    targetUpdated: Yn(t, e) ? { oldTarget: t.target, newTarget: e.target } : void 0
+  };
+};
+var D = /* @__PURE__ */ ((t) => (t.LOCAL = "LOCAL", t.REMOTE = "REMOTE", t))(D || {});
+const _n = (t, e) => {
+  var n, o;
+  const { changes: r, origin: i } = e;
+  if (!(!t.options.origin || t.options.origin === i))
+    return !1;
+  if (t.options.ignore) {
+    const { ignore: a } = t.options, s = (l) => (l == null ? void 0 : l.length) > 0;
+    if (!(s(r.created) || s(r.deleted))) {
+      const l = (n = r.updated) == null ? void 0 : n.some((p) => s(p.bodiesCreated) || s(p.bodiesDeleted) || s(p.bodiesUpdated)), d = (o = r.updated) == null ? void 0 : o.some((p) => p.targetUpdated);
+      if (a === "BODY_ONLY" && l && !d || a === "TARGET_ONLY" && d && !l)
+        return !1;
+    }
+  }
+  if (t.options.annotations) {
+    const a = /* @__PURE__ */ new Set([
+      ...r.created.map((s) => s.id),
+      ...r.deleted.map((s) => s.id),
+      ...r.updated.map(({ oldValue: s }) => s.id)
+    ]);
+    return !!(Array.isArray(t.options.annotations) ? t.options.annotations : [t.options.annotations]).find((s) => a.has(s));
+  } else
+    return !0;
+}, Cn = (t, e) => {
+  const n = new Set((t.created || []).map((c) => c.id)), o = new Set((t.updated || []).map(({ newValue: c }) => c.id)), r = new Set((e.created || []).map((c) => c.id)), i = new Set((e.deleted || []).map((c) => c.id)), a = new Set((e.updated || []).map(({ oldValue: c }) => c.id)), s = new Set((e.updated || []).filter(({ oldValue: c }) => n.has(c.id) || o.has(c.id)).map(({ oldValue: c }) => c.id)), l = [
+    ...(t.created || []).filter((c) => !i.has(c.id)).map((c) => a.has(c.id) ? e.updated.find(({ oldValue: f }) => f.id === c.id).newValue : c),
+    ...e.created || []
+  ], d = [
+    ...(t.deleted || []).filter((c) => !r.has(c.id)),
+    ...(e.deleted || []).filter((c) => !n.has(c.id))
+  ], p = [
+    ...(t.updated || []).filter(({ newValue: c }) => !i.has(c.id)).map((c) => {
+      const { oldValue: f, newValue: h } = c;
+      if (a.has(h.id)) {
+        const m = e.updated.find((x) => x.oldValue.id === h.id).newValue;
+        return je(f, m);
+      } else
+        return c;
+    }),
+    ...(e.updated || []).filter(({ oldValue: c }) => !s.has(c.id))
+  ];
+  return { created: l, deleted: d, updated: p };
+}, Pn = (t) => t.id !== void 0, On = () => {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map(), n = [], o = (g, b = {}) => n.push({ onChange: g, options: b }), r = (g) => {
+    const b = n.findIndex((w) => w.onChange == g);
+    b > -1 && n.splice(b, 1);
+  }, i = (g, b) => {
+    const w = {
+      origin: g,
+      changes: {
+        created: b.created || [],
+        updated: b.updated || [],
+        deleted: b.deleted || []
+      },
+      state: [...t.values()]
+    };
+    n.forEach((T) => {
+      _n(T, w) && T.onChange(w);
+    });
+  }, a = (g, b = D.LOCAL) => {
+    if (t.get(g.id))
+      throw Error(`Cannot add annotation ${g.id} - exists already`);
+    t.set(g.id, g), g.bodies.forEach((w) => e.set(w.id, g.id)), i(b, { created: [g] });
+  }, s = (g, b) => {
+    const w = typeof g == "string" ? b : g, T = typeof g == "string" ? g : g.id, X = t.get(T);
+    if (X) {
+      const P = je(X, w);
+      return T === w.id ? t.set(T, w) : (t.delete(T), t.set(w.id, w)), X.bodies.forEach((J) => e.delete(J.id)), w.bodies.forEach((J) => e.set(J.id, w.id)), P;
+    } else
+      console.warn(`Cannot update annotation ${T} - does not exist`);
+  }, l = (g, b = D.LOCAL, w = D.LOCAL) => {
+    const T = Pn(b) ? w : b, X = s(g, b);
+    X && i(T, { updated: [X] });
+  }, d = (g, b = D.LOCAL) => {
+    const w = g.reduce((T, X) => {
+      const P = s(X);
+      return P ? [...T, P] : T;
+    }, []);
+    w.length > 0 && i(b, { updated: w });
+  }, p = (g, b = D.LOCAL) => {
+    const w = t.get(g.annotation);
+    if (w) {
+      const T = {
+        ...w,
+        bodies: [...w.bodies, g]
+      };
+      t.set(w.id, T), e.set(g.id, T.id), i(b, { updated: [{
+        oldValue: w,
+        newValue: T,
+        bodiesCreated: [g]
+      }] });
+    } else
+      console.warn(`Attempt to add body to missing annotation: ${g.annotation}`);
+  }, c = () => [...t.values()], f = (g = D.LOCAL) => {
+    const b = [...t.values()];
+    t.clear(), e.clear(), i(g, { deleted: b });
+  }, h = (g, b = !0, w = D.LOCAL) => {
+    if (b) {
+      const T = [...t.values()];
+      t.clear(), e.clear(), g.forEach((X) => {
+        t.set(X.id, X), X.bodies.forEach((P) => e.set(P.id, X.id));
+      }), i(w, { created: g, deleted: T });
+    } else {
+      const T = g.reduce((X, P) => {
+        const J = t.get(P.id);
+        return J ? [...X, J] : X;
+      }, []);
+      if (T.length > 0)
+        throw Error(`Bulk insert would overwrite the following annotations: ${T.map((X) => X.id).join(", ")}`);
+      g.forEach((X) => {
+        t.set(X.id, X), X.bodies.forEach((P) => e.set(P.id, X.id));
+      }), i(w, { created: g });
+    }
+  }, m = (g) => {
+    const b = typeof g == "string" ? g : g.id, w = t.get(b);
+    if (w)
+      return t.delete(b), w.bodies.forEach((T) => e.delete(T.id)), w;
+    console.warn(`Attempt to delete missing annotation: ${b}`);
+  }, x = (g, b = D.LOCAL) => {
+    const w = m(g);
+    w && i(b, { deleted: [w] });
+  }, A = (g, b = D.LOCAL) => {
+    const w = g.reduce((T, X) => {
+      const P = m(X);
+      return P ? [...T, P] : T;
+    }, []);
+    w.length > 0 && i(b, { deleted: w });
+  }, $ = (g, b = D.LOCAL) => {
+    const w = t.get(g.annotation);
+    if (w) {
+      const T = w.bodies.find((X) => X.id === g.id);
+      if (T) {
+        e.delete(T.id);
+        const X = {
+          ...w,
+          bodies: w.bodies.filter((P) => P.id !== g.id)
+        };
+        t.set(w.id, X), i(b, { updated: [{
+          oldValue: w,
+          newValue: X,
+          bodiesDeleted: [T]
+        }] });
+      } else
+        console.warn(`Attempt to delete missing body ${g.id} from annotation ${g.annotation}`);
+    } else
+      console.warn(`Attempt to delete body from missing annotation ${g.annotation}`);
+  }, y = (g) => {
+    const b = t.get(g);
+    return b ? { ...b } : void 0;
+  }, v = (g) => {
+    const b = e.get(g);
+    if (b) {
+      const w = y(b).bodies.find((T) => T.id === g);
+      if (w)
+        return w;
+      console.error(`Store integrity error: body ${g} in index, but not in annotation`);
+    } else
+      console.warn(`Attempt to retrieve missing body: ${g}`);
+  }, E = (g, b) => {
+    if (g.annotation !== b.annotation)
+      throw "Annotation integrity violation: annotation ID must be the same when updating bodies";
+    const w = t.get(g.annotation);
+    if (w) {
+      const T = w.bodies.find((P) => P.id === g.id), X = {
+        ...w,
+        bodies: w.bodies.map((P) => P.id === T.id ? b : P)
+      };
+      return t.set(w.id, X), T.id !== b.id && (e.delete(T.id), e.set(b.id, X.id)), {
+        oldValue: w,
+        newValue: X,
+        bodiesUpdated: [{ oldBody: T, newBody: b }]
+      };
+    } else
+      console.warn(`Attempt to add body to missing annotation ${g.annotation}`);
+  }, _ = (g, b, w = D.LOCAL) => {
+    const T = E(g, b);
+    i(w, { updated: [T] });
+  }, C = (g, b = D.LOCAL) => {
+    const w = g.map((T) => E({ id: T.id, annotation: T.annotation }, T));
+    i(b, { updated: w });
+  }, N = (g) => {
+    const b = t.get(g.annotation);
+    if (b) {
+      const w = {
+        ...b,
+        target: {
+          ...b.target,
+          ...g
+        }
+      };
+      return t.set(b.id, w), {
+        oldValue: b,
+        newValue: w,
+        targetUpdated: {
+          oldTarget: b.target,
+          newTarget: g
+        }
+      };
+    } else
+      console.warn(`Attempt to update target on missing annotation: ${g.annotation}`);
+  };
+  return {
+    addAnnotation: a,
+    addBody: p,
+    all: c,
+    bulkAddAnnotation: h,
+    bulkDeleteAnnotation: A,
+    bulkUpdateAnnotation: d,
+    bulkUpdateBodies: C,
+    bulkUpdateTargets: (g, b = D.LOCAL) => {
+      const w = g.map(N).filter((T) => T);
+      w.length > 0 && i(b, { updated: w });
+    },
+    clear: f,
+    deleteAnnotation: x,
+    deleteBody: $,
+    getAnnotation: y,
+    getBody: v,
+    observe: o,
+    unobserve: r,
+    updateAnnotation: l,
+    updateBody: _,
+    updateTarget: (g, b = D.LOCAL) => {
+      const w = N(g);
+      w && i(b, { updated: [w] });
+    }
+  };
+}, Vn = (t) => ({
+  ...t,
+  subscribe: (e) => {
+    const n = (o) => e(o.state);
+    return t.observe(n), e(t.all()), () => t.unobserve(n);
+  }
+});
+let kn = () => ({
+  emit(t, ...e) {
+    let n = this.events[t] || [];
+    for (let o = 0, r = n.length; o < r; o++)
+      n[o](...e);
+  },
+  events: {},
+  on(t, e) {
+    var n;
+    return (n = this.events[t]) != null && n.push(e) || (this.events[t] = [e]), () => {
+      var o;
+      this.events[t] = (o = this.events[t]) == null ? void 0 : o.filter((r) => e !== r);
+    };
+  }
+});
+const Nn = 250, Dn = (t) => {
+  const e = kn(), n = [];
+  let o = -1, r = !1, i = 0;
+  const a = (h) => {
+    if (!r) {
+      const { changes: m } = h, x = performance.now();
+      if (x - i > Nn)
+        n.splice(o + 1), n.push(m), o = n.length - 1;
+      else {
+        const A = n.length - 1;
+        n[A] = Cn(n[A], m);
+      }
+      i = x;
+    }
+    r = !1;
+  };
+  t.observe(a, { origin: D.LOCAL });
+  const s = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkDeleteAnnotation(h), l = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkAddAnnotation(h, !1), d = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkUpdateAnnotation(h.map(({ oldValue: m }) => m)), p = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkUpdateAnnotation(h.map(({ newValue: m }) => m)), c = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkAddAnnotation(h, !1), f = (h) => (h == null ? void 0 : h.length) > 0 && t.bulkDeleteAnnotation(h);
+  return {
+    canRedo: () => n.length - 1 > o,
+    canUndo: () => o > -1,
+    destroy: () => t.unobserve(a),
+    on: (h, m) => e.on(h, m),
+    redo: () => {
+      if (n.length - 1 > o) {
+        r = !0;
+        const { created: h, updated: m, deleted: x } = n[o + 1];
+        l(h), p(m), f(x), e.emit("redo", n[o + 1]), o += 1;
+      }
+    },
+    undo: () => {
+      if (o > -1) {
+        r = !0;
+        const { created: h, updated: m, deleted: x } = n[o];
+        s(h), d(m), c(x), e.emit("undo", n[o]), o -= 1;
+      }
+    }
+  };
+}, Gn = () => {
+  const { subscribe: t, set: e } = Ut([]);
+  return {
+    subscribe: t,
+    set: e
+  };
+}, Un = (t, e, n, o) => {
+  const { store: r, selection: i, hover: a, viewport: s } = t, l = /* @__PURE__ */ new Map();
+  let d = [], p, c;
+  const f = ($, y) => {
+    l.has($) ? l.get($).push(y) : l.set($, [y]);
+  }, h = ($, y) => {
+    const v = l.get($);
+    v && v.indexOf(y) > 0 && v.splice(v.indexOf(y), 1);
+  }, m = ($, y, v) => {
+    l.has($) && setTimeout(() => {
+      l.get($).forEach((E) => {
+        if (n) {
+          const _ = Array.isArray(y) ? y.map((N) => n.serialize(N)) : n.serialize(y), C = v ? v instanceof PointerEvent ? v : n.serialize(v) : void 0;
+          E(_, C);
+        } else
+          E(y, v);
+      });
+    }, 1);
+  }, x = () => {
+    const { selected: $ } = i, y = $.map(({ id: v }) => r.getAnnotation(v));
+    y.forEach((v) => {
+      const E = d.find((_) => _.id === v.id);
+      (!E || !pt(E, v)) && m("updateAnnotation", v, E);
+    }), d = d.map((v) => y.find(({ id: _ }) => _ === v.id) || v);
+  };
+  i.subscribe(({ selected: $ }) => {
+    if (!(d.length === 0 && $.length === 0)) {
+      if (d.length === 0 && $.length > 0)
+        d = $.map(({ id: y }) => r.getAnnotation(y));
+      else if (d.length > 0 && $.length === 0)
+        d.forEach((y) => {
+          const v = r.getAnnotation(y.id);
+          v && !pt(v, y) && m("updateAnnotation", v, y);
+        }), d = [];
+      else {
+        const y = new Set(d.map((E) => E.id)), v = new Set($.map(({ id: E }) => E));
+        d.filter((E) => !v.has(E.id)).forEach((E) => {
+          const _ = r.getAnnotation(E.id);
+          _ && !pt(_, E) && m("updateAnnotation", _, E);
+        }), d = [
+          // Remove annotations that were deselected
+          ...d.filter((E) => v.has(E.id)),
+          // Add editable annotations that were selected
+          ...$.filter(({ id: E }) => !y.has(E)).map(({ id: E }) => r.getAnnotation(E))
+        ];
+      }
+      m("selectionChanged", d);
+    }
+  }), a.subscribe(($) => {
+    !p && $ ? m("mouseEnterAnnotation", r.getAnnotation($)) : p && !$ ? m("mouseLeaveAnnotation", r.getAnnotation(p)) : p && $ && (m("mouseLeaveAnnotation", r.getAnnotation(p)), m("mouseEnterAnnotation", r.getAnnotation($))), p = $;
+  }), s == null || s.subscribe(($) => m("viewportIntersect", $.map(r.getAnnotation))), r.observe(($) => {
+    o && (c && clearTimeout(c), c = setTimeout(x, 1e3));
+    const { created: y, deleted: v } = $.changes;
+    y.forEach((E) => m("createAnnotation", E)), v.forEach((E) => m("deleteAnnotation", E)), $.changes.updated.filter((E) => [
+      ...E.bodiesCreated || [],
+      ...E.bodiesDeleted || [],
+      ...E.bodiesUpdated || []
+    ].length > 0).forEach(({ oldValue: E, newValue: _ }) => {
+      const C = d.find((N) => N.id === E.id) || E;
+      d = d.map((N) => N.id === E.id ? _ : N), m("updateAnnotation", _, C);
+    });
+  }, { origin: D.LOCAL }), r.observe(($) => {
+    if (d) {
+      const y = new Set(d.map((E) => E.id)), v = $.changes.updated.filter(({ newValue: E }) => y.has(E.id)).map(({ newValue: E }) => E);
+      v.length > 0 && (d = d.map((E) => v.find((C) => C.id === E.id) || E));
+    }
+  }, { origin: D.REMOTE });
+  const A = ($) => (y) => {
+    const { created: v, deleted: E, updated: _ } = y;
+    v.forEach((C) => m("createAnnotation", C)), E.forEach((C) => m("deleteAnnotation", C)), $ ? _.forEach((C) => m("updateAnnotation", C.oldValue, C.newValue)) : _.forEach((C) => m("updateAnnotation", C.newValue, C.oldValue));
+  };
+  return e.on("undo", A(!0)), e.on("redo", A(!1)), { on: f, off: h, emit: m };
+}, Fn = (t) => (e) => e.reduce((n, o) => {
+  const { parsed: r, error: i } = t.parse(o);
+  return i ? {
+    parsed: n.parsed,
+    failed: [...n.failed, o]
+  } : {
+    parsed: [...n.parsed, r],
+    failed: n.failed
+  };
+}, { parsed: [], failed: [] }), Hn = (t, e, n) => {
+  const { store: o, selection: r } = t, i = (A) => {
+    if (n) {
+      const { parsed: $, error: y } = n.parse(A);
+      $ ? o.addAnnotation($, D.REMOTE) : console.error(y);
+    } else
+      o.addAnnotation(A, D.REMOTE);
+  }, a = () => r.clear(), s = () => o.clear(), l = (A) => {
+    const $ = o.getAnnotation(A);
+    return n && $ ? n.serialize($) : $;
+  }, d = () => n ? o.all().map(n.serialize) : o.all(), p = () => {
+    var A;
+    const $ = (((A = r.selected) == null ? void 0 : A.map((y) => y.id)) || []).map((y) => o.getAnnotation(y));
+    return n ? $.map(n.serialize) : $;
+  }, c = (A) => fetch(A).then(($) => $.json()).then(($) => (h($), $)), f = (A) => {
+    if (typeof A == "string") {
+      const $ = o.getAnnotation(A);
+      return o.deleteAnnotation(A), n ? n.serialize($) : $;
+    } else {
+      const $ = n ? n.parse(A).parsed : A;
+      return o.deleteAnnotation($), A;
+    }
+  }, h = (A) => {
+    if (n) {
+      const { parsed: $, failed: y } = Fn(n)(A);
+      y.length > 0 && console.warn(`Discarded ${y.length} invalid annotations`, y), o.bulkAddAnnotation($, !0, D.REMOTE);
+    } else
+      o.bulkAddAnnotation(A, !0, D.REMOTE);
+  }, m = (A) => {
+    A ? r.setSelected(A) : r.clear();
+  }, x = (A) => {
+    if (n) {
+      const $ = n.parse(A).parsed, y = n.serialize(o.getAnnotation($.id));
+      return o.updateAnnotation($), y;
+    } else {
+      const $ = o.getAnnotation(A.id);
+      return o.updateAnnotation(A), $;
+    }
+  };
+  return {
+    addAnnotation: i,
+    cancelSelected: a,
+    canRedo: e.canRedo,
+    canUndo: e.canUndo,
+    clearAnnotations: s,
+    getAnnotationById: l,
+    getAnnotations: d,
+    getSelected: p,
+    loadAnnotations: c,
+    redo: e.redo,
+    removeAnnotation: f,
+    setAnnotations: h,
+    setSelected: m,
+    undo: e.undo,
+    updateAnnotation: x
+  };
+};
+let jn = (t) => crypto.getRandomValues(new Uint8Array(t)), zn = (t, e, n) => {
+  let o = (2 << Math.log(t.length - 1) / Math.LN2) - 1, r = -~(1.6 * o * e / t.length);
+  return (i = e) => {
+    let a = "";
+    for (; ; ) {
+      let s = n(r), l = r;
+      for (; l--; )
+        if (a += t[s[l] & o] || "", a.length === i)
+          return a;
+    }
+  };
+}, Rn = (t, e = 21) => zn(t, e, jn), qn = (t = 21) => crypto.getRandomValues(new Uint8Array(t)).reduce((e, n) => (n &= 63, n < 36 ? e += n.toString(36) : n < 62 ? e += (n - 26).toString(36).toUpperCase() : n > 62 ? e += "-" : e += "_", e), "");
+const Wn = () => ({ isGuest: !0, id: Rn("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", 20)() }), Kn = (t) => {
+  const e = JSON.stringify(t);
+  let n = 0;
+  for (let o = 0, r = e.length; o < r; o++) {
+    let i = e.charCodeAt(o);
+    n = (n << 5) - n + i, n |= 0;
+  }
+  return `${n}`;
+}, Jn = (t, e) => (Array.isArray(t) ? t : [t]).map((n) => {
+  const { id: o, type: r, purpose: i, value: a, created: s, creator: l, ...d } = n;
+  return {
+    id: o || `temp-${Kn(n)}`,
+    annotation: e,
+    type: r,
+    purpose: i,
+    value: a,
+    created: s,
+    creator: l ? typeof l == "object" ? { ...l } : l : void 0,
+    ...d
+  };
+}), Qn = (t) => t.map((e) => {
+  var n;
+  const o = { ...e };
+  return delete o.annotation, (n = o.id) != null && n.startsWith("temp-") && delete o.id, o;
+});
+qn();
+const pr = (t, e = !1) => ({ parse: (n) => Zn(n, e), serialize: (n) => to(n, t) }), Zn = (t, e = !1) => {
+  const n = t.id || Fe(), { body: o, ...r } = t, i = Jn(o, n), a = Array.isArray(t.target) ? t.target[0] : t.target, s = Array.isArray(a.selector) ? a.selector[0] : a.selector, l = s.type === "FragmentSelector" ? fn(s, e) : s.type === "SvgSelector" ? xn(s) : void 0;
+  return l ? {
+    parsed: {
+      ...r,
+      id: n,
+      bodies: i,
+      target: {
+        annotation: n,
+        selector: l
+      }
+    }
+  } : {
+    error: Error(`Unknown selector type: ${s.type}`)
+  };
+}, to = (t, e) => {
+  const n = t.target.selector, o = n.type == F.RECTANGLE ? gn(n.geometry) : bn(n);
+  return {
+    ...t,
+    "@context": "http://www.w3.org/ns/anno.jsonld",
+    id: t.id,
+    type: "Annotation",
+    body: Qn(t.bodies),
+    target: {
+      source: e,
+      selector: o
+    }
+  };
+};
+function ge(t, e, n) {
+  const o = t.slice();
+  return o[11] = e[n], o[13] = n, o;
+}
+function me(t) {
+  let e, n, o, r, i;
+  return {
+    c() {
+      e = O("rect"), u(e, "class", "a9s-corner-handle"), u(e, "x", n = /*point*/
+      t[11][0] - /*handleSize*/
+      t[3] / 2), u(e, "y", o = /*point*/
+      t[11][1] - /*handleSize*/
+      t[3] / 2), u(
+        e,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        e,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    m(a, s) {
+      B(a, e, s), r || (i = R(e, "pointerdown", function() {
+        H(
+          /*grab*/
+          t[10](M(
+            /*idx*/
+            t[13]
+          ))
+        ) && t[10](M(
+          /*idx*/
+          t[13]
+        )).apply(this, arguments);
+      }), r = !0);
+    },
+    p(a, s) {
+      t = a, s & /*geom, handleSize*/
+      24 && n !== (n = /*point*/
+      t[11][0] - /*handleSize*/
+      t[3] / 2) && u(e, "x", n), s & /*geom, handleSize*/
+      24 && o !== (o = /*point*/
+      t[11][1] - /*handleSize*/
+      t[3] / 2) && u(e, "y", o), s & /*handleSize*/
+      8 && u(
+        e,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), s & /*handleSize*/
+      8 && u(
+        e,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    d(a) {
+      a && L(e), r = !1, i();
+    }
+  };
+}
+function eo(t) {
+  let e, n, o, r, i, a, s, l, d, p, c = (
+    /*geom*/
+    t[4].points
+  ), f = [];
+  for (let h = 0; h < c.length; h += 1)
+    f[h] = me(ge(t, c, h));
+  return {
+    c() {
+      e = O("polygon"), r = tt(), i = O("polygon"), s = tt();
+      for (let h = 0; h < f.length; h += 1)
+        f[h].c();
+      l = at(), u(e, "class", "a9s-outer"), u(e, "style", n = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), u(e, "points", o = /*geom*/
+      t[4].points.map(ye).join(" ")), u(i, "class", "a9s-inner a9s-shape-handle"), u(
+        i,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), u(i, "points", a = /*geom*/
+      t[4].points.map($e).join(" "));
+    },
+    m(h, m) {
+      B(h, e, m), B(h, r, m), B(h, i, m), B(h, s, m);
+      for (let x = 0; x < f.length; x += 1)
+        f[x] && f[x].m(h, m);
+      B(h, l, m), d || (p = [
+        R(e, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.SHAPE)
+          ) && t[10](M.SHAPE).apply(this, arguments);
+        }),
+        R(i, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.SHAPE)
+          ) && t[10](M.SHAPE).apply(this, arguments);
+        })
+      ], d = !0);
+    },
+    p(h, m) {
+      if (t = h, m & /*computedStyle*/
+      2 && n !== (n = /*computedStyle*/
+      t[1] ? "display:none;" : void 0) && u(e, "style", n), m & /*geom*/
+      16 && o !== (o = /*geom*/
+      t[4].points.map(ye).join(" ")) && u(e, "points", o), m & /*computedStyle*/
+      2 && u(
+        i,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), m & /*geom*/
+      16 && a !== (a = /*geom*/
+      t[4].points.map($e).join(" ")) && u(i, "points", a), m & /*geom, handleSize, grab, Handle*/
+      1048) {
+        c = /*geom*/
+        t[4].points;
+        let x;
+        for (x = 0; x < c.length; x += 1) {
+          const A = ge(t, c, x);
+          f[x] ? f[x].p(A, m) : (f[x] = me(A), f[x].c(), f[x].m(l.parentNode, l));
+        }
+        for (; x < f.length; x += 1)
+          f[x].d(1);
+        f.length = c.length;
+      }
+    },
+    d(h) {
+      h && L(e), h && L(r), h && L(i), h && L(s), oe(f, h), h && L(l), d = !1, it(p);
+    }
+  };
+}
+function no(t) {
+  let e, n;
+  return e = new Re({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          eo,
+          ({ grab: o }) => ({ 10: o }),
+          ({ grab: o }) => o ? 1024 : 0
+        ]
+      },
+      $$scope: { ctx: t }
+    }
+  }), e.$on(
+    "change",
+    /*change_handler*/
+    t[7]
+  ), e.$on(
+    "grab",
+    /*grab_handler*/
+    t[8]
+  ), e.$on(
+    "release",
+    /*release_handler*/
+    t[9]
+  ), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, [r]) {
+      const i = {};
+      r & /*shape*/
+      1 && (i.shape = /*shape*/
+      o[0]), r & /*transform*/
+      4 && (i.transform = /*transform*/
+      o[2]), r & /*$$scope, geom, handleSize, grab, computedStyle*/
+      17434 && (i.$$scope = { dirty: r, ctx: o }), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+const ye = (t) => t.join(","), $e = (t) => t.join(",");
+function oo(t, e, n) {
+  let o, r, { shape: i } = e, { computedStyle: a = void 0 } = e, { transform: s } = e, { viewportScale: l = 1 } = e;
+  const d = (h, m, x) => {
+    let A;
+    m === M.SHAPE ? A = h.geometry.points.map(([y, v]) => [y + x[0], v + x[1]]) : A = h.geometry.points.map(([y, v], E) => m === M(E) ? [y + x[0], v + x[1]] : [y, v]);
+    const $ = Gt(A);
+    return { ...h, geometry: { points: A, bounds: $ } };
+  };
+  function p(h) {
+    vt.call(this, t, h);
+  }
+  function c(h) {
+    vt.call(this, t, h);
+  }
+  function f(h) {
+    vt.call(this, t, h);
+  }
+  return t.$$set = (h) => {
+    "shape" in h && n(0, i = h.shape), "computedStyle" in h && n(1, a = h.computedStyle), "transform" in h && n(2, s = h.transform), "viewportScale" in h && n(6, l = h.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && n(4, o = i.geometry), t.$$.dirty & /*viewportScale*/
+    64 && n(3, r = 10 / l);
+  }, [
+    i,
+    a,
+    s,
+    r,
+    o,
+    d,
+    l,
+    p,
+    c,
+    f
+  ];
+}
+class ro extends nt {
+  constructor(e) {
+    super(), et(this, e, oo, no, K, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 6
+    });
+  }
+}
+function io(t) {
+  let e, n, o, r, i, a, s, l, d, p, c, f, h, m, x, A, $, y, v, E, _, C, N, g, b, w, T, X, P, J, gt, mt, Tt, W, I, q, j, G, st, lt, Ht, Q, Yt, _t, jt, Z, Ct, Pt, zt, se;
+  return {
+    c() {
+      e = O("rect"), s = tt(), l = O("rect"), h = tt(), m = O("rect"), y = tt(), v = O("rect"), N = tt(), g = O("rect"), X = tt(), P = O("rect"), Tt = tt(), W = O("rect"), j = tt(), G = O("rect"), Ht = tt(), Q = O("rect"), jt = tt(), Z = O("rect"), u(e, "class", "a9s-outer"), u(e, "style", n = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), u(e, "x", o = /*geom*/
+      t[4].x), u(e, "y", r = /*geom*/
+      t[4].y), u(e, "width", i = /*geom*/
+      t[4].w), u(e, "height", a = /*geom*/
+      t[4].h), u(l, "class", "a9s-inner a9s-shape-handle"), u(
+        l,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), u(l, "x", d = /*geom*/
+      t[4].x), u(l, "y", p = /*geom*/
+      t[4].y), u(l, "width", c = /*geom*/
+      t[4].w), u(l, "height", f = /*geom*/
+      t[4].h), u(m, "class", "a9s-edge-handle a9s-edge-handle-top"), u(m, "x", x = /*geom*/
+      t[4].x), u(m, "y", A = /*geom*/
+      t[4].y), u(m, "height", 1), u(m, "width", $ = /*geom*/
+      t[4].w), u(v, "class", "a9s-edge-handle a9s-edge-handle-right"), u(v, "x", E = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w), u(v, "y", _ = /*geom*/
+      t[4].y), u(v, "height", C = /*geom*/
+      t[4].h), u(v, "width", 1), u(g, "class", "a9s-edge-handle a9s-edge-handle-bottom"), u(g, "x", b = /*geom*/
+      t[4].x), u(g, "y", w = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h), u(g, "height", 1), u(g, "width", T = /*geom*/
+      t[4].w), u(P, "class", "a9s-edge-handle a9s-edge-handle-left"), u(P, "x", J = /*geom*/
+      t[4].x), u(P, "y", gt = /*geom*/
+      t[4].y), u(P, "height", mt = /*geom*/
+      t[4].h), u(P, "width", 1), u(W, "class", "a9s-corner-handle a9s-corner-handle-topleft"), u(W, "x", I = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2), u(W, "y", q = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2), u(
+        W,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        W,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u(G, "class", "a9s-corner-handle a9s-corner-handle-topright"), u(G, "x", st = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2), u(G, "y", lt = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2), u(
+        G,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        G,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u(Q, "class", "a9s-corner-handle a9s-corner-handle-bottomright"), u(Q, "x", Yt = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2), u(Q, "y", _t = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2), u(
+        Q,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        Q,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u(Z, "class", "a9s-corner-handle a9s-corner-handle-bottomleft"), u(Z, "x", Ct = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2), u(Z, "y", Pt = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2), u(
+        Z,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        Z,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    m(Y, S) {
+      B(Y, e, S), B(Y, s, S), B(Y, l, S), B(Y, h, S), B(Y, m, S), B(Y, y, S), B(Y, v, S), B(Y, N, S), B(Y, g, S), B(Y, X, S), B(Y, P, S), B(Y, Tt, S), B(Y, W, S), B(Y, j, S), B(Y, G, S), B(Y, Ht, S), B(Y, Q, S), B(Y, jt, S), B(Y, Z, S), zt || (se = [
+        R(e, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.SHAPE)
+          ) && t[10](M.SHAPE).apply(this, arguments);
+        }),
+        R(l, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.SHAPE)
+          ) && t[10](M.SHAPE).apply(this, arguments);
+        }),
+        R(m, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.TOP)
+          ) && t[10](M.TOP).apply(this, arguments);
+        }),
+        R(v, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.RIGHT)
+          ) && t[10](M.RIGHT).apply(this, arguments);
+        }),
+        R(g, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.BOTTOM)
+          ) && t[10](M.BOTTOM).apply(this, arguments);
+        }),
+        R(P, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.LEFT)
+          ) && t[10](M.LEFT).apply(this, arguments);
+        }),
+        R(W, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.TOP_LEFT)
+          ) && t[10](M.TOP_LEFT).apply(this, arguments);
+        }),
+        R(G, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.TOP_RIGHT)
+          ) && t[10](M.TOP_RIGHT).apply(this, arguments);
+        }),
+        R(Q, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.BOTTOM_RIGHT)
+          ) && t[10](M.BOTTOM_RIGHT).apply(this, arguments);
+        }),
+        R(Z, "pointerdown", function() {
+          H(
+            /*grab*/
+            t[10](M.BOTTOM_LEFT)
+          ) && t[10](M.BOTTOM_LEFT).apply(this, arguments);
+        })
+      ], zt = !0);
+    },
+    p(Y, S) {
+      t = Y, S & /*computedStyle*/
+      2 && n !== (n = /*computedStyle*/
+      t[1] ? "display:none;" : void 0) && u(e, "style", n), S & /*geom*/
+      16 && o !== (o = /*geom*/
+      t[4].x) && u(e, "x", o), S & /*geom*/
+      16 && r !== (r = /*geom*/
+      t[4].y) && u(e, "y", r), S & /*geom*/
+      16 && i !== (i = /*geom*/
+      t[4].w) && u(e, "width", i), S & /*geom*/
+      16 && a !== (a = /*geom*/
+      t[4].h) && u(e, "height", a), S & /*computedStyle*/
+      2 && u(
+        l,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), S & /*geom*/
+      16 && d !== (d = /*geom*/
+      t[4].x) && u(l, "x", d), S & /*geom*/
+      16 && p !== (p = /*geom*/
+      t[4].y) && u(l, "y", p), S & /*geom*/
+      16 && c !== (c = /*geom*/
+      t[4].w) && u(l, "width", c), S & /*geom*/
+      16 && f !== (f = /*geom*/
+      t[4].h) && u(l, "height", f), S & /*geom*/
+      16 && x !== (x = /*geom*/
+      t[4].x) && u(m, "x", x), S & /*geom*/
+      16 && A !== (A = /*geom*/
+      t[4].y) && u(m, "y", A), S & /*geom*/
+      16 && $ !== ($ = /*geom*/
+      t[4].w) && u(m, "width", $), S & /*geom*/
+      16 && E !== (E = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w) && u(v, "x", E), S & /*geom*/
+      16 && _ !== (_ = /*geom*/
+      t[4].y) && u(v, "y", _), S & /*geom*/
+      16 && C !== (C = /*geom*/
+      t[4].h) && u(v, "height", C), S & /*geom*/
+      16 && b !== (b = /*geom*/
+      t[4].x) && u(g, "x", b), S & /*geom*/
+      16 && w !== (w = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h) && u(g, "y", w), S & /*geom*/
+      16 && T !== (T = /*geom*/
+      t[4].w) && u(g, "width", T), S & /*geom*/
+      16 && J !== (J = /*geom*/
+      t[4].x) && u(P, "x", J), S & /*geom*/
+      16 && gt !== (gt = /*geom*/
+      t[4].y) && u(P, "y", gt), S & /*geom*/
+      16 && mt !== (mt = /*geom*/
+      t[4].h) && u(P, "height", mt), S & /*geom, handleSize*/
+      24 && I !== (I = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2) && u(W, "x", I), S & /*geom, handleSize*/
+      24 && q !== (q = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2) && u(W, "y", q), S & /*handleSize*/
+      8 && u(
+        W,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), S & /*handleSize*/
+      8 && u(
+        W,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), S & /*geom, handleSize*/
+      24 && st !== (st = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2) && u(G, "x", st), S & /*geom, handleSize*/
+      24 && lt !== (lt = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2) && u(G, "y", lt), S & /*handleSize*/
+      8 && u(
+        G,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), S & /*handleSize*/
+      8 && u(
+        G,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), S & /*geom, handleSize*/
+      24 && Yt !== (Yt = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2) && u(Q, "x", Yt), S & /*geom, handleSize*/
+      24 && _t !== (_t = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2) && u(Q, "y", _t), S & /*handleSize*/
+      8 && u(
+        Q,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), S & /*handleSize*/
+      8 && u(
+        Q,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), S & /*geom, handleSize*/
+      24 && Ct !== (Ct = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2) && u(Z, "x", Ct), S & /*geom, handleSize*/
+      24 && Pt !== (Pt = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2) && u(Z, "y", Pt), S & /*handleSize*/
+      8 && u(
+        Z,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), S & /*handleSize*/
+      8 && u(
+        Z,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    d(Y) {
+      Y && L(e), Y && L(s), Y && L(l), Y && L(h), Y && L(m), Y && L(y), Y && L(v), Y && L(N), Y && L(g), Y && L(X), Y && L(P), Y && L(Tt), Y && L(W), Y && L(j), Y && L(G), Y && L(Ht), Y && L(Q), Y && L(jt), Y && L(Z), zt = !1, it(se);
+    }
+  };
+}
+function ao(t) {
+  let e, n;
+  return e = new Re({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          io,
+          ({ grab: o }) => ({ 10: o }),
+          ({ grab: o }) => o ? 1024 : 0
+        ]
+      },
+      $$scope: { ctx: t }
+    }
+  }), e.$on(
+    "grab",
+    /*grab_handler*/
+    t[7]
+  ), e.$on(
+    "change",
+    /*change_handler*/
+    t[8]
+  ), e.$on(
+    "release",
+    /*release_handler*/
+    t[9]
+  ), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, [r]) {
+      const i = {};
+      r & /*shape*/
+      1 && (i.shape = /*shape*/
+      o[0]), r & /*transform*/
+      4 && (i.transform = /*transform*/
+      o[2]), r & /*$$scope, geom, handleSize, grab, computedStyle*/
+      3098 && (i.$$scope = { dirty: r, ctx: o }), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function so(t, e, n) {
+  let o, r, { shape: i } = e, { computedStyle: a = void 0 } = e, { transform: s } = e, { viewportScale: l = 1 } = e;
+  const d = (h, m, x) => {
+    const A = h.geometry.bounds;
+    let [$, y] = [A.minX, A.minY], [v, E] = [A.maxX, A.maxY];
+    const [_, C] = x;
+    if (m === M.SHAPE)
+      $ += _, v += _, y += C, E += C;
+    else {
+      switch (m) {
+        case M.TOP:
+        case M.TOP_LEFT:
+        case M.TOP_RIGHT: {
+          y += C;
+          break;
+        }
+        case M.BOTTOM:
+        case M.BOTTOM_LEFT:
+        case M.BOTTOM_RIGHT: {
+          E += C;
+          break;
+        }
+      }
+      switch (m) {
+        case M.LEFT:
+        case M.TOP_LEFT:
+        case M.BOTTOM_LEFT: {
+          $ += _;
+          break;
+        }
+        case M.RIGHT:
+        case M.TOP_RIGHT:
+        case M.BOTTOM_RIGHT: {
+          v += _;
+          break;
+        }
+      }
+    }
+    const N = Math.min($, v), g = Math.min(y, E), b = Math.abs(v - $), w = Math.abs(E - y);
+    return {
+      ...h,
+      geometry: {
+        x: N,
+        y: g,
+        w: b,
+        h: w,
+        bounds: {
+          minX: N,
+          minY: g,
+          maxX: N + b,
+          maxY: g + w
+        }
+      }
+    };
+  };
+  function p(h) {
+    vt.call(this, t, h);
+  }
+  function c(h) {
+    vt.call(this, t, h);
+  }
+  function f(h) {
+    vt.call(this, t, h);
+  }
+  return t.$$set = (h) => {
+    "shape" in h && n(0, i = h.shape), "computedStyle" in h && n(1, a = h.computedStyle), "transform" in h && n(2, s = h.transform), "viewportScale" in h && n(6, l = h.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && n(4, o = i.geometry), t.$$.dirty & /*viewportScale*/
+    64 && n(3, r = 10 / l);
+  }, [
+    i,
+    a,
+    s,
+    r,
+    o,
+    d,
+    l,
+    p,
+    c,
+    f
+  ];
+}
+class lo extends nt {
+  constructor(e) {
+    super(), et(this, e, so, ao, K, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 6
+    });
+  }
+}
+const ze = /* @__PURE__ */ new Map([
+  [F.RECTANGLE, lo],
+  [F.POLYGON, ro]
+]), we = (t) => ze.get(t.type), co = (t, e) => ze.set(t, e), M = (t) => `HANDLE-${t}`;
+M.SHAPE = "SHAPE";
+M.TOP = "TOP";
+M.RIGHT = "RIGHT";
+M.BOTTOM = "BOTTOM";
+M.LEFT = "LEFT";
+M.TOP_LEFT = "TOP_LEFT";
+M.TOP_RIGHT = "TOP_RIGHT";
+M.BOTTOM_RIGHT = "BOTTOM_RIGHT";
+M.BOTTOM_LEFT = "BOTTOM_LEFT";
+const uo = (t) => ({}), xe = (t) => ({ grab: (
+  /*onGrab*/
+  t[0]
+) });
+function ho(t) {
+  let e, n, o, r;
+  const i = (
+    /*#slots*/
+    t[7].default
+  ), a = Qe(
+    i,
+    t,
+    /*$$scope*/
+    t[6],
+    xe
+  );
+  return {
+    c() {
+      e = O("g"), a && a.c(), u(e, "class", "a9s-annotation selected");
+    },
+    m(s, l) {
+      B(s, e, l), a && a.m(e, null), n = !0, o || (r = [
+        R(
+          e,
+          "pointerup",
+          /*onRelease*/
+          t[2]
+        ),
+        R(
+          e,
+          "pointermove",
+          /*onPointerMove*/
+          t[1]
+        )
+      ], o = !0);
+    },
+    p(s, [l]) {
+      a && a.p && (!n || l & /*$$scope*/
+      64) && tn(
+        a,
+        i,
+        s,
+        /*$$scope*/
+        s[6],
+        n ? Ze(
+          i,
+          /*$$scope*/
+          s[6],
+          l,
+          uo
+        ) : en(
+          /*$$scope*/
+          s[6]
+        ),
+        xe
+      );
+    },
+    i(s) {
+      n || (V(a, s), n = !0);
+    },
+    o(s) {
+      k(a, s), n = !1;
+    },
+    d(s) {
+      s && L(e), a && a.d(s), o = !1, it(r);
+    }
+  };
+}
+function po(t, e, n) {
+  let { $$slots: o = {}, $$scope: r } = e;
+  const i = At();
+  let { shape: a } = e, { editor: s } = e, { transform: l } = e, d = null, p, c = null;
+  const f = (x) => (A) => {
+    d = x, p = l.elementToImage(A.offsetX, A.offsetY), c = a, A.target.setPointerCapture(A.pointerId), i("grab");
+  }, h = (x) => {
+    if (d) {
+      const [A, $] = l.elementToImage(x.offsetX, x.offsetY), y = [A - p[0], $ - p[1]];
+      n(3, a = s(c, d, y)), i("change", a);
+    }
+  }, m = (x) => {
+    x.target.releasePointerCapture(x.pointerId), d = null, c = a, i("release");
+  };
+  return t.$$set = (x) => {
+    "shape" in x && n(3, a = x.shape), "editor" in x && n(4, s = x.editor), "transform" in x && n(5, l = x.transform), "$$scope" in x && n(6, r = x.$$scope);
+  }, [f, h, m, a, s, l, r, o];
+}
+class Re extends nt {
+  constructor(e) {
+    super(), et(this, e, po, ho, K, { shape: 3, editor: 4, transform: 5 });
+  }
+}
+const Ft = (t, e) => {
+  const n = typeof e == "function" ? e(t) : e;
+  if (n) {
+    const { fill: o, fillOpacity: r } = n;
+    let i = "";
+    return o && (i += `fill:${o};stroke:${o};`), i += `fill-opacity:${r || "0.25"};`, i;
+  }
+};
+function fo(t, e, n) {
+  let o;
+  const r = At();
+  let { annotation: i } = e, { editor: a } = e, { style: s = void 0 } = e, { target: l } = e, { transform: d } = e, { viewportScale: p } = e, c;
+  return It(() => (n(6, c = new a({
+    target: l,
+    props: {
+      shape: i.target.selector,
+      computedStyle: o,
+      transform: d,
+      viewportScale: p
+    }
+  })), c.$on("change", (f) => {
+    c.$$set({ shape: f.detail }), r("change", f.detail);
+  }), c.$on("grab", (f) => r("grab", f.detail)), c.$on("release", (f) => r("release", f.detail)), () => {
+    c.$destroy();
+  })), t.$$set = (f) => {
+    "annotation" in f && n(0, i = f.annotation), "editor" in f && n(1, a = f.editor), "style" in f && n(2, s = f.style), "target" in f && n(3, l = f.target), "transform" in f && n(4, d = f.transform), "viewportScale" in f && n(5, p = f.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*annotation, style*/
+    5 && (o = Ft(i, s)), t.$$.dirty & /*annotation, editorComponent*/
+    65 && i && (c == null || c.$set({ shape: i.target.selector })), t.$$.dirty & /*editorComponent, transform*/
+    80 && c && c.$set({ transform: d }), t.$$.dirty & /*editorComponent, viewportScale*/
+    96 && c && c.$set({ viewportScale: p });
+  }, [i, a, s, l, d, p, c];
+}
+class go extends nt {
+  constructor(e) {
+    super(), et(this, e, fo, null, K, {
+      annotation: 0,
+      editor: 1,
+      style: 2,
+      target: 3,
+      transform: 4,
+      viewportScale: 5
+    });
+  }
+}
+function mo(t, e, n) {
+  const o = At();
+  let { drawingMode: r } = e, { target: i } = e, { tool: a } = e, { transform: s } = e, { viewportScale: l } = e, d;
+  return It(() => {
+    const p = i.closest("svg"), c = [], f = (h, m, x) => {
+      p.addEventListener(h, m, x), c.push(() => p.removeEventListener(h, m, x));
+    };
+    return n(5, d = new a({
+      target: i,
+      props: {
+        addEventListener: f,
+        drawingMode: r,
+        transform: s,
+        viewportScale: l
+      }
+    })), d.$on("create", (h) => o("create", h.detail)), () => {
+      c.forEach((h) => h()), d.$destroy();
+    };
+  }), t.$$set = (p) => {
+    "drawingMode" in p && n(0, r = p.drawingMode), "target" in p && n(1, i = p.target), "tool" in p && n(2, a = p.tool), "transform" in p && n(3, s = p.transform), "viewportScale" in p && n(4, l = p.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*toolComponent, transform*/
+    40 && d && d.$set({ transform: s }), t.$$.dirty & /*toolComponent, viewportScale*/
+    48 && d && d.$set({ viewportScale: l });
+  }, [r, i, a, s, l, d];
+}
+class yo extends nt {
+  constructor(e) {
+    super(), et(this, e, mo, null, K, {
+      drawingMode: 0,
+      target: 1,
+      tool: 2,
+      transform: 3,
+      viewportScale: 4
+    });
+  }
+}
+function be(t) {
+  let e, n;
+  return {
+    c() {
+      e = O("rect"), n = O("rect"), u(e, "class", "a9s-outer"), u(
+        e,
+        "x",
+        /*x*/
+        t[1]
+      ), u(
+        e,
+        "y",
+        /*y*/
+        t[2]
+      ), u(
+        e,
+        "width",
+        /*w*/
+        t[3]
+      ), u(
+        e,
+        "height",
+        /*h*/
+        t[4]
+      ), u(n, "class", "a9s-inner"), u(
+        n,
+        "x",
+        /*x*/
+        t[1]
+      ), u(
+        n,
+        "y",
+        /*y*/
+        t[2]
+      ), u(
+        n,
+        "width",
+        /*w*/
+        t[3]
+      ), u(
+        n,
+        "height",
+        /*h*/
+        t[4]
+      );
+    },
+    m(o, r) {
+      B(o, e, r), B(o, n, r);
+    },
+    p(o, r) {
+      r & /*x*/
+      2 && u(
+        e,
+        "x",
+        /*x*/
+        o[1]
+      ), r & /*y*/
+      4 && u(
+        e,
+        "y",
+        /*y*/
+        o[2]
+      ), r & /*w*/
+      8 && u(
+        e,
+        "width",
+        /*w*/
+        o[3]
+      ), r & /*h*/
+      16 && u(
+        e,
+        "height",
+        /*h*/
+        o[4]
+      ), r & /*x*/
+      2 && u(
+        n,
+        "x",
+        /*x*/
+        o[1]
+      ), r & /*y*/
+      4 && u(
+        n,
+        "y",
+        /*y*/
+        o[2]
+      ), r & /*w*/
+      8 && u(
+        n,
+        "width",
+        /*w*/
+        o[3]
+      ), r & /*h*/
+      16 && u(
+        n,
+        "height",
+        /*h*/
+        o[4]
+      );
+    },
+    d(o) {
+      o && L(e), o && L(n);
+    }
+  };
+}
+function $o(t) {
+  let e, n = (
+    /*origin*/
+    t[0] && be(t)
+  );
+  return {
+    c() {
+      e = O("g"), n && n.c(), u(e, "class", "a9s-annotation a9s-rubberband");
+    },
+    m(o, r) {
+      B(o, e, r), n && n.m(e, null);
+    },
+    p(o, [r]) {
+      o[0] ? n ? n.p(o, r) : (n = be(o), n.c(), n.m(e, null)) : n && (n.d(1), n = null);
+    },
+    i: U,
+    o: U,
+    d(o) {
+      o && L(e), n && n.d();
+    }
+  };
+}
+function wo(t, e, n) {
+  const o = At();
+  let { addEventListener: r } = e, { drawingMode: i } = e, { transform: a } = e, s, l, d, p, c, f, h;
+  const m = (y) => {
+    s = performance.now(), i === "drag" && (n(0, l = a.elementToImage(y.offsetX, y.offsetY)), d = l, n(1, p = l[0]), n(2, c = l[1]), n(3, f = 1), n(4, h = 1));
+  }, x = (y) => {
+    l && (d = a.elementToImage(y.offsetX, y.offsetY), n(1, p = Math.min(d[0], l[0])), n(2, c = Math.min(d[1], l[1])), n(3, f = Math.abs(d[0] - l[0])), n(4, h = Math.abs(d[1] - l[1])));
+  }, A = (y) => {
+    const v = performance.now() - s;
+    if (i === "click") {
+      if (v > 300)
+        return;
+      y.stopPropagation(), l ? $() : (n(0, l = a.elementToImage(y.offsetX, y.offsetY)), d = l, n(1, p = l[0]), n(2, c = l[1]), n(3, f = 1), n(4, h = 1));
+    } else
+      l && (v > 300 || f * h > 100 ? (y.stopPropagation(), $()) : (n(0, l = null), d = null));
+  }, $ = () => {
+    if (f * h > 15) {
+      const y = {
+        type: F.RECTANGLE,
+        geometry: {
+          bounds: {
+            minX: p,
+            minY: c,
+            maxX: p + f,
+            maxY: c + h
+          },
+          x: p,
+          y: c,
+          w: f,
+          h
+        }
+      };
+      o("create", y);
+    }
+    n(0, l = null), d = null;
+  };
+  return It(() => {
+    r("pointerdown", m), r("pointermove", x), r("pointerup", A, !0);
+  }), t.$$set = (y) => {
+    "addEventListener" in y && n(5, r = y.addEventListener), "drawingMode" in y && n(6, i = y.drawingMode), "transform" in y && n(7, a = y.transform);
+  }, [l, p, c, f, h, r, i, a];
+}
+class xo extends nt {
+  constructor(e) {
+    super(), et(this, e, wo, $o, K, {
+      addEventListener: 5,
+      drawingMode: 6,
+      transform: 7
+    });
+  }
+}
+const Wt = (t, e) => {
+  const n = Math.abs(e[0] - t[0]), o = Math.abs(e[1] - t[1]);
+  return Math.sqrt(Math.pow(n, 2) + Math.pow(o, 2));
+}, bo = (t, e) => {
+  const { naturalWidth: n, naturalHeight: o } = t;
+  if (!n && !o) {
+    const { width: r, height: i } = t;
+    e.setAttribute("viewBox", `0 0 ${r} ${i}`), t.addEventListener("load", (a) => {
+      const s = a.target;
+      e.setAttribute("viewBox", `0 0 ${s.naturalWidth} ${s.naturalHeight}`);
+    });
+  } else
+    e.setAttribute("viewBox", `0 0 ${n} ${o}`);
+}, vo = (t, e) => {
+  bo(t, e);
+  const { subscribe: n, set: o } = Ut(1);
+  let r;
+  return window.ResizeObserver && (r = new ResizeObserver(() => {
+    const i = e.getBoundingClientRect(), { width: a, height: s } = e.viewBox.baseVal, l = Math.max(
+      i.width / a,
+      i.height / s
+    );
+    o(l);
+  }), r.observe(e.parentElement)), { destroy: () => {
+    r && r.disconnect();
+  }, subscribe: n };
+};
+function Kt(t) {
+  const e = t.slice(), n = (
+    /*isClosable*/
+    (e[2] ? (
+      /*points*/
+      e[0]
+    ) : [
+      .../*points*/
+      e[0],
+      /*cursor*/
+      e[1]
+    ]).map((o) => o.join(",")).join(" ")
+  );
+  return e[15] = n, e;
+}
+function ve(t) {
+  let e, n, o, r, i, a = (
+    /*isClosable*/
+    t[2] && Ee(t)
+  );
+  return {
+    c() {
+      e = O("polygon"), o = O("polygon"), a && a.c(), i = at(), u(e, "class", "a9s-outer"), u(e, "points", n = /*coords*/
+      t[15]), u(o, "class", "a9s-inner"), u(o, "points", r = /*coords*/
+      t[15]);
+    },
+    m(s, l) {
+      B(s, e, l), B(s, o, l), a && a.m(s, l), B(s, i, l);
+    },
+    p(s, l) {
+      l & /*isClosable, points, cursor*/
+      7 && n !== (n = /*coords*/
+      s[15]) && u(e, "points", n), l & /*isClosable, points, cursor*/
+      7 && r !== (r = /*coords*/
+      s[15]) && u(o, "points", r), /*isClosable*/
+      s[2] ? a ? a.p(s, l) : (a = Ee(s), a.c(), a.m(i.parentNode, i)) : a && (a.d(1), a = null);
+    },
+    d(s) {
+      s && L(e), s && L(o), a && a.d(s), s && L(i);
+    }
+  };
+}
+function Ee(t) {
+  let e, n, o;
+  return {
+    c() {
+      e = O("rect"), u(e, "class", "a9s-corner-handle"), u(e, "x", n = /*points*/
+      t[0][0][0] - /*handleSize*/
+      t[3] / 2), u(e, "y", o = /*points*/
+      t[0][0][1] - /*handleSize*/
+      t[3] / 2), u(
+        e,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u(
+        e,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    m(r, i) {
+      B(r, e, i);
+    },
+    p(r, i) {
+      i & /*points, handleSize*/
+      9 && n !== (n = /*points*/
+      r[0][0][0] - /*handleSize*/
+      r[3] / 2) && u(e, "x", n), i & /*points, handleSize*/
+      9 && o !== (o = /*points*/
+      r[0][0][1] - /*handleSize*/
+      r[3] / 2) && u(e, "y", o), i & /*handleSize*/
+      8 && u(
+        e,
+        "height",
+        /*handleSize*/
+        r[3]
+      ), i & /*handleSize*/
+      8 && u(
+        e,
+        "width",
+        /*handleSize*/
+        r[3]
+      );
+    },
+    d(r) {
+      r && L(e);
+    }
+  };
+}
+function Eo(t) {
+  let e, n = (
+    /*cursor*/
+    t[1] && ve(Kt(t))
+  );
+  return {
+    c() {
+      e = O("g"), n && n.c(), u(e, "class", "a9s-annotation a9s-rubberband");
+    },
+    m(o, r) {
+      B(o, e, r), n && n.m(e, null);
+    },
+    p(o, [r]) {
+      o[1] ? n ? n.p(Kt(o), r) : (n = ve(Kt(o)), n.c(), n.m(e, null)) : n && (n.d(1), n = null);
+    },
+    i: U,
+    o: U,
+    d(o) {
+      o && L(e), n && n.d();
+    }
+  };
+}
+const Ao = 20;
+function To(t, e, n) {
+  let o;
+  const r = At();
+  let { addEventListener: i } = e, { drawingMode: a } = e, { transform: s } = e, { viewportScale: l = 1 } = e, d, p = [], c = null, f = !1;
+  const h = (y) => {
+    const { timeStamp: v, offsetX: E, offsetY: _ } = y;
+    if (d = { timeStamp: v, offsetX: E, offsetY: _ }, a === "drag" && p.length === 0) {
+      const C = s.elementToImage(y.offsetX, y.offsetY);
+      p.push(C), n(1, c = C);
+    }
+  }, m = (y) => {
+    if (p.length > 0 && (n(1, c = s.elementToImage(y.offsetX, y.offsetY)), p.length > 2)) {
+      const v = Wt(c, p[0]) * l;
+      n(2, f = v < Ao);
+    }
+  }, x = (y) => {
+    if (a === "click") {
+      const v = y.timeStamp - d.timeStamp, E = Wt([d.offsetX, d.offsetY], [y.offsetX, y.offsetY]);
+      if (v > 300 || E > 15)
+        return;
+      if (f)
+        $();
+      else if (p.length === 0) {
+        const _ = s.elementToImage(y.offsetX, y.offsetY);
+        p.push(_), n(1, c = _);
+      } else
+        p.push(c);
+    } else {
+      if (p.length === 1 && Wt(p[0], c) <= 4) {
+        n(0, p = []), n(1, c = null);
+        return;
+      }
+      y.stopImmediatePropagation(), f ? $() : p.push(c);
+    }
+  }, A = () => {
+    const y = [...p, c], v = {
+      type: F.POLYGON,
+      geometry: { bounds: Gt(y), points: y }
+    };
+    ne(v) > 4 && (n(0, p = []), n(1, c = null), r("create", v));
+  }, $ = () => {
+    const y = {
+      type: F.POLYGON,
+      geometry: {
+        bounds: Gt(p),
+        points: [...p]
+      }
+    };
+    n(0, p = []), n(1, c = null), r("create", y);
+  };
+  return It(() => {
+    i("pointerdown", h, !0), i("pointermove", m), i("pointerup", x, !0), i("dblclick", A, !0);
+  }), t.$$set = (y) => {
+    "addEventListener" in y && n(4, i = y.addEventListener), "drawingMode" in y && n(5, a = y.drawingMode), "transform" in y && n(6, s = y.transform), "viewportScale" in y && n(7, l = y.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*viewportScale*/
+    128 && n(3, o = 10 / l);
+  }, [
+    p,
+    c,
+    f,
+    o,
+    i,
+    a,
+    s,
+    l
+  ];
+}
+class So extends nt {
+  constructor(e) {
+    super(), et(this, e, To, Eo, K, {
+      addEventListener: 4,
+      drawingMode: 5,
+      transform: 6,
+      viewportScale: 7
+    });
+  }
+}
+const ae = /* @__PURE__ */ new Map([
+  ["rectangle", { tool: xo }],
+  ["polygon", { tool: So }]
+]), Mo = () => [...ae.keys()], qe = (t) => ae.get(t), Lo = (t, e, n) => ae.set(t, { tool: e, opts: n });
+function Bo(t) {
+  let e, n, o, r, i;
+  return {
+    c() {
+      e = O("g"), n = O("ellipse"), r = O("ellipse"), u(n, "class", "a9s-outer"), u(n, "style", o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), u(
+        n,
+        "cx",
+        /*cx*/
+        t[2]
+      ), u(
+        n,
+        "cy",
+        /*cy*/
+        t[3]
+      ), u(
+        n,
+        "rx",
+        /*rx*/
+        t[4]
+      ), u(
+        n,
+        "ry",
+        /*ry*/
+        t[5]
+      ), u(r, "class", "a9s-inner"), u(
+        r,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), u(
+        r,
+        "cx",
+        /*cx*/
+        t[2]
+      ), u(
+        r,
+        "cy",
+        /*cy*/
+        t[3]
+      ), u(
+        r,
+        "rx",
+        /*rx*/
+        t[4]
+      ), u(
+        r,
+        "ry",
+        /*ry*/
+        t[5]
+      ), u(e, "data-id", i = /*annotation*/
+      t[0].id);
+    },
+    m(a, s) {
+      B(a, e, s), dt(e, n), dt(e, r);
+    },
+    p(a, [s]) {
+      s & /*computedStyle*/
+      2 && o !== (o = /*computedStyle*/
+      a[1] ? "display:none;" : void 0) && u(n, "style", o), s & /*computedStyle*/
+      2 && u(
+        r,
+        "style",
+        /*computedStyle*/
+        a[1]
+      ), s & /*annotation*/
+      1 && i !== (i = /*annotation*/
+      a[0].id) && u(e, "data-id", i);
+    },
+    i: U,
+    o: U,
+    d(a) {
+      a && L(e);
+    }
+  };
+}
+function Xo(t, e, n) {
+  let o, { annotation: r } = e, { geom: i } = e, { style: a = void 0 } = e;
+  const { cx: s, cy: l, rx: d, ry: p } = i;
+  return t.$$set = (c) => {
+    "annotation" in c && n(0, r = c.annotation), "geom" in c && n(6, i = c.geom), "style" in c && n(7, a = c.style);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*annotation, style*/
+    129 && n(1, o = Ft(r, a));
+  }, [r, o, s, l, d, p, i, a];
+}
+class Io extends nt {
+  constructor(e) {
+    super(), et(this, e, Xo, Bo, K, { annotation: 0, geom: 6, style: 7 });
+  }
+}
+function Yo(t) {
+  let e, n, o, r, i;
+  return {
+    c() {
+      e = O("g"), n = O("polygon"), r = O("polygon"), u(n, "class", "a9s-outer"), u(n, "style", o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), u(
+        n,
+        "points",
+        /*points*/
+        t[2].map(_o).join(" ")
+      ), u(r, "class", "a9s-inner"), u(
+        r,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), u(
+        r,
+        "points",
+        /*points*/
+        t[2].map(Co).join(" ")
+      ), u(e, "data-id", i = /*annotation*/
+      t[0].id);
+    },
+    m(a, s) {
+      B(a, e, s), dt(e, n), dt(e, r);
+    },
+    p(a, [s]) {
+      s & /*computedStyle*/
+      2 && o !== (o = /*computedStyle*/
+      a[1] ? "display:none;" : void 0) && u(n, "style", o), s & /*computedStyle*/
+      2 && u(
+        r,
+        "style",
+        /*computedStyle*/
+        a[1]
+      ), s & /*annotation*/
+      1 && i !== (i = /*annotation*/
+      a[0].id) && u(e, "data-id", i);
+    },
+    i: U,
+    o: U,
+    d(a) {
+      a && L(e);
+    }
+  };
+}
+const _o = (t) => t.join(","), Co = (t) => t.join(",");
+function Po(t, e, n) {
+  let o, { annotation: r } = e, { geom: i } = e, { style: a = void 0 } = e;
+  const { points: s } = i;
+  return t.$$set = (l) => {
+    "annotation" in l && n(0, r = l.annotation), "geom" in l && n(3, i = l.geom), "style" in l && n(4, a = l.style);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*annotation, style*/
+    17 && n(1, o = Ft(r, a));
+  }, [r, o, s, i, a];
+}
+class Oo extends nt {
+  constructor(e) {
+    super(), et(this, e, Po, Yo, K, { annotation: 0, geom: 3, style: 4 });
+  }
+}
+function Vo(t) {
+  let e, n, o, r, i;
+  return {
+    c() {
+      e = O("g"), n = O("rect"), r = O("rect"), u(n, "class", "a9s-outer"), u(n, "style", o = /*computedStyle*/
+      t[5] ? "display:none;" : void 0), u(
+        n,
+        "x",
+        /*x*/
+        t[4]
+      ), u(
+        n,
+        "y",
+        /*y*/
+        t[3]
+      ), u(
+        n,
+        "width",
+        /*w*/
+        t[2]
+      ), u(
+        n,
+        "height",
+        /*h*/
+        t[1]
+      ), u(r, "class", "a9s-inner"), u(
+        r,
+        "style",
+        /*computedStyle*/
+        t[5]
+      ), u(
+        r,
+        "x",
+        /*x*/
+        t[4]
+      ), u(
+        r,
+        "y",
+        /*y*/
+        t[3]
+      ), u(
+        r,
+        "width",
+        /*w*/
+        t[2]
+      ), u(
+        r,
+        "height",
+        /*h*/
+        t[1]
+      ), u(e, "data-id", i = /*annotation*/
+      t[0].id);
+    },
+    m(a, s) {
+      B(a, e, s), dt(e, n), dt(e, r);
+    },
+    p(a, [s]) {
+      s & /*computedStyle*/
+      32 && o !== (o = /*computedStyle*/
+      a[5] ? "display:none;" : void 0) && u(n, "style", o), s & /*x*/
+      16 && u(
+        n,
+        "x",
+        /*x*/
+        a[4]
+      ), s & /*y*/
+      8 && u(
+        n,
+        "y",
+        /*y*/
+        a[3]
+      ), s & /*w*/
+      4 && u(
+        n,
+        "width",
+        /*w*/
+        a[2]
+      ), s & /*h*/
+      2 && u(
+        n,
+        "height",
+        /*h*/
+        a[1]
+      ), s & /*computedStyle*/
+      32 && u(
+        r,
+        "style",
+        /*computedStyle*/
+        a[5]
+      ), s & /*x*/
+      16 && u(
+        r,
+        "x",
+        /*x*/
+        a[4]
+      ), s & /*y*/
+      8 && u(
+        r,
+        "y",
+        /*y*/
+        a[3]
+      ), s & /*w*/
+      4 && u(
+        r,
+        "width",
+        /*w*/
+        a[2]
+      ), s & /*h*/
+      2 && u(
+        r,
+        "height",
+        /*h*/
+        a[1]
+      ), s & /*annotation*/
+      1 && i !== (i = /*annotation*/
+      a[0].id) && u(e, "data-id", i);
+    },
+    i: U,
+    o: U,
+    d(a) {
+      a && L(e);
+    }
+  };
+}
+function ko(t, e, n) {
+  let o, r, i, a, s, { annotation: l } = e, { geom: d } = e, { style: p = void 0 } = e;
+  return t.$$set = (c) => {
+    "annotation" in c && n(0, l = c.annotation), "geom" in c && n(6, d = c.geom), "style" in c && n(7, p = c.style);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*annotation, style*/
+    129 && n(5, o = Ft(l, p)), t.$$.dirty & /*geom*/
+    64 && n(4, { x: r, y: i, w: a, h: s } = d, r, (n(3, i), n(6, d)), (n(2, a), n(6, d)), (n(1, s), n(6, d)));
+  }, [l, s, a, i, r, o, d, p];
+}
+class No extends nt {
+  constructor(e) {
+    super(), et(this, e, ko, Vo, K, { annotation: 0, geom: 6, style: 7 });
+  }
+}
+const Do = (t) => ({
+  elementToImage: (e, n) => {
+    const o = t.getBoundingClientRect(), r = t.createSVGPoint();
+    r.x = e + o.x, r.y = n + o.y;
+    const { x: i, y: a } = r.matrixTransform(t.getScreenCTM().inverse());
+    return [i, a];
+  }
+}), Go = 250, Uo = (t, e) => {
+  const n = At();
+  let o;
+  return { onPointerDown: () => o = performance.now(), onPointerUp: (r) => {
+    if (performance.now() - o < Go) {
+      const { x: i, y: a } = Fo(r, t), s = e.getAt(i, a);
+      s ? n("click", { originalEvent: r, annotation: s }) : n("click", { originalEvent: r });
+    }
+  } };
+}, Fo = (t, e) => {
+  const n = e.createSVGPoint(), o = e.getBoundingClientRect(), r = t.clientX - o.x, i = t.clientY - o.y, { left: a, top: s } = e.getBoundingClientRect();
+  return n.x = r + a, n.y = i + s, n.matrixTransform(e.getScreenCTM().inverse());
+};
+function Ae(t, e, n) {
+  const o = t.slice();
+  return o[28] = e[n], o;
+}
+function Te(t, e, n) {
+  const o = t.slice();
+  return o[31] = e[n], o;
+}
+function Jt(t) {
+  const e = t.slice(), n = (
+    /*annotation*/
+    e[31].target.selector
+  );
+  return e[34] = n, e;
+}
+function Se(t) {
+  let e = (
+    /*annotation*/
+    t[31].id
+  ), n, o, r = Me(t);
+  return {
+    c() {
+      r.c(), n = at();
+    },
+    m(i, a) {
+      r.m(i, a), B(i, n, a), o = !0;
+    },
+    p(i, a) {
+      a[0] & /*$store*/
+      4096 && K(e, e = /*annotation*/
+      i[31].id) ? (ot(), k(r, 1, 1, U), rt(), r = Me(i), r.c(), V(r, 1), r.m(n.parentNode, n)) : r.p(i, a);
+    },
+    i(i) {
+      o || (V(r), o = !0);
+    },
+    o(i) {
+      k(r), o = !1;
+    },
+    d(i) {
+      i && L(n), r.d(i);
+    }
+  };
+}
+function Ho(t) {
+  let e, n;
+  return e = new Oo({
+    props: {
+      annotation: (
+        /*annotation*/
+        t[31]
+      ),
+      geom: (
+        /*selector*/
+        t[34].geometry
+      ),
+      style: (
+        /*style*/
+        t[1]
+      )
+    }
+  }), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, r) {
+      const i = {};
+      r[0] & /*$store*/
+      4096 && (i.annotation = /*annotation*/
+      o[31]), r[0] & /*$store*/
+      4096 && (i.geom = /*selector*/
+      o[34].geometry), r[0] & /*style*/
+      2 && (i.style = /*style*/
+      o[1]), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function jo(t) {
+  let e, n;
+  return e = new No({
+    props: {
+      annotation: (
+        /*annotation*/
+        t[31]
+      ),
+      geom: (
+        /*selector*/
+        t[34].geometry
+      ),
+      style: (
+        /*style*/
+        t[1]
+      )
+    }
+  }), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, r) {
+      const i = {};
+      r[0] & /*$store*/
+      4096 && (i.annotation = /*annotation*/
+      o[31]), r[0] & /*$store*/
+      4096 && (i.geom = /*selector*/
+      o[34].geometry), r[0] & /*style*/
+      2 && (i.style = /*style*/
+      o[1]), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function zo(t) {
+  let e, n;
+  return e = new Io({
+    props: {
+      annotation: (
+        /*annotation*/
+        t[31]
+      ),
+      geom: (
+        /*selector*/
+        t[34].geometry
+      ),
+      style: (
+        /*style*/
+        t[1]
+      )
+    }
+  }), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, r) {
+      const i = {};
+      r[0] & /*$store*/
+      4096 && (i.annotation = /*annotation*/
+      o[31]), r[0] & /*$store*/
+      4096 && (i.geom = /*selector*/
+      o[34].geometry), r[0] & /*style*/
+      2 && (i.style = /*style*/
+      o[1]), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function Me(t) {
+  let e, n, o, r;
+  const i = [zo, jo, Ho], a = [];
+  function s(l, d) {
+    return (
+      /*selector*/
+      l[34].type === F.ELLIPSE ? 0 : (
+        /*selector*/
+        l[34].type === F.RECTANGLE ? 1 : (
+          /*selector*/
+          l[34].type === F.POLYGON ? 2 : -1
+        )
+      )
+    );
+  }
+  return ~(e = s(t)) && (n = a[e] = i[e](t)), {
+    c() {
+      n && n.c(), o = at();
+    },
+    m(l, d) {
+      ~e && a[e].m(l, d), B(l, o, d), r = !0;
+    },
+    p(l, d) {
+      let p = e;
+      e = s(l), e === p ? ~e && a[e].p(l, d) : (n && (ot(), k(a[p], 1, 1, () => {
+        a[p] = null;
+      }), rt()), ~e ? (n = a[e], n ? n.p(l, d) : (n = a[e] = i[e](l), n.c()), V(n, 1), n.m(o.parentNode, o)) : n = null);
+    },
+    i(l) {
+      r || (V(n), r = !0);
+    },
+    o(l) {
+      k(n), r = !1;
+    },
+    d(l) {
+      ~e && a[e].d(l), l && L(o);
+    }
+  };
+}
+function Le(t) {
+  let e = !/*isEditable*/
+  t[7](
+    /*annotation*/
+    t[31]
+  ), n, o, r = e && Se(Jt(t));
+  return {
+    c() {
+      r && r.c(), n = at();
+    },
+    m(i, a) {
+      r && r.m(i, a), B(i, n, a), o = !0;
+    },
+    p(i, a) {
+      a[0] & /*isEditable, $store*/
+      4224 && (e = !/*isEditable*/
+      i[7](
+        /*annotation*/
+        i[31]
+      )), e ? r ? (r.p(Jt(i), a), a[0] & /*isEditable, $store*/
+      4224 && V(r, 1)) : (r = Se(Jt(i)), r.c(), V(r, 1), r.m(n.parentNode, n)) : r && (ot(), k(r, 1, 1, () => {
+        r = null;
+      }), rt());
+    },
+    i(i) {
+      o || (V(r), o = !0);
+    },
+    o(i) {
+      k(r), o = !1;
+    },
+    d(i) {
+      r && r.d(i), i && L(n);
+    }
+  };
+}
+function Be(t) {
+  let e, n, o, r;
+  const i = [qo, Ro], a = [];
+  function s(l, d) {
+    return (
+      /*editableAnnotations*/
+      l[6] ? 0 : (
+        /*tool*/
+        l[2] && /*drawingEnabled*/
+        l[0] ? 1 : -1
+      )
+    );
+  }
+  return ~(e = s(t)) && (n = a[e] = i[e](t)), {
+    c() {
+      n && n.c(), o = at();
+    },
+    m(l, d) {
+      ~e && a[e].m(l, d), B(l, o, d), r = !0;
+    },
+    p(l, d) {
+      let p = e;
+      e = s(l), e === p ? ~e && a[e].p(l, d) : (n && (ot(), k(a[p], 1, 1, () => {
+        a[p] = null;
+      }), rt()), ~e ? (n = a[e], n ? n.p(l, d) : (n = a[e] = i[e](l), n.c()), V(n, 1), n.m(o.parentNode, o)) : n = null);
+    },
+    i(l) {
+      r || (V(n), r = !0);
+    },
+    o(l) {
+      k(n), r = !1;
+    },
+    d(l) {
+      ~e && a[e].d(l), l && L(o);
+    }
+  };
+}
+function Ro(t) {
+  let e = (
+    /*tool*/
+    t[2]
+  ), n, o, r = Xe(t);
+  return {
+    c() {
+      r.c(), n = at();
+    },
+    m(i, a) {
+      r.m(i, a), B(i, n, a), o = !0;
+    },
+    p(i, a) {
+      a[0] & /*tool*/
+      4 && K(e, e = /*tool*/
+      i[2]) ? (ot(), k(r, 1, 1, U), rt(), r = Xe(i), r.c(), V(r, 1), r.m(n.parentNode, n)) : r.p(i, a);
+    },
+    i(i) {
+      o || (V(r), o = !0);
+    },
+    o(i) {
+      k(r), o = !1;
+    },
+    d(i) {
+      i && L(n), r.d(i);
+    }
+  };
+}
+function qo(t) {
+  let e, n, o = (
+    /*editableAnnotations*/
+    t[6]
+  ), r = [];
+  for (let a = 0; a < o.length; a += 1)
+    r[a] = Ye(Ae(t, o, a));
+  const i = (a) => k(r[a], 1, 1, () => {
+    r[a] = null;
+  });
+  return {
+    c() {
+      for (let a = 0; a < r.length; a += 1)
+        r[a].c();
+      e = at();
+    },
+    m(a, s) {
+      for (let l = 0; l < r.length; l += 1)
+        r[l] && r[l].m(a, s);
+      B(a, e, s), n = !0;
+    },
+    p(a, s) {
+      if (s[0] & /*editableAnnotations, drawingEl, style, transform, $scale, onChangeSelected*/
+      140370) {
+        o = /*editableAnnotations*/
+        a[6];
+        let l;
+        for (l = 0; l < o.length; l += 1) {
+          const d = Ae(a, o, l);
+          r[l] ? (r[l].p(d, s), V(r[l], 1)) : (r[l] = Ye(d), r[l].c(), V(r[l], 1), r[l].m(e.parentNode, e));
+        }
+        for (ot(), l = o.length; l < r.length; l += 1)
+          i(l);
+        rt();
+      }
+    },
+    i(a) {
+      if (!n) {
+        for (let s = 0; s < o.length; s += 1)
+          V(r[s]);
+        n = !0;
+      }
+    },
+    o(a) {
+      r = r.filter(Boolean);
+      for (let s = 0; s < r.length; s += 1)
+        k(r[s]);
+      n = !1;
+    },
+    d(a) {
+      oe(r, a), a && L(e);
+    }
+  };
+}
+function Xe(t) {
+  let e, n;
+  return e = new yo({
+    props: {
+      target: (
+        /*drawingEl*/
+        t[4]
+      ),
+      tool: (
+        /*tool*/
+        t[2]
+      ),
+      drawingMode: (
+        /*drawingMode*/
+        t[11]
+      ),
+      transform: (
+        /*transform*/
+        t[10]
+      ),
+      viewportScale: (
+        /*$scale*/
+        t[13]
+      )
+    }
+  }), e.$on(
+    "create",
+    /*onSelectionCreated*/
+    t[16]
+  ), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, r) {
+      const i = {};
+      r[0] & /*drawingEl*/
+      16 && (i.target = /*drawingEl*/
+      o[4]), r[0] & /*tool*/
+      4 && (i.tool = /*tool*/
+      o[2]), r[0] & /*drawingMode*/
+      2048 && (i.drawingMode = /*drawingMode*/
+      o[11]), r[0] & /*transform*/
+      1024 && (i.transform = /*transform*/
+      o[10]), r[0] & /*$scale*/
+      8192 && (i.viewportScale = /*$scale*/
+      o[13]), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function Ie(t) {
+  let e, n;
+  return e = new go({
+    props: {
+      target: (
+        /*drawingEl*/
+        t[4]
+      ),
+      editor: we(
+        /*editable*/
+        t[28].target.selector
+      ),
+      annotation: (
+        /*editable*/
+        t[28]
+      ),
+      style: (
+        /*style*/
+        t[1]
+      ),
+      transform: (
+        /*transform*/
+        t[10]
+      ),
+      viewportScale: (
+        /*$scale*/
+        t[13]
+      )
+    }
+  }), e.$on("change", function() {
+    H(
+      /*onChangeSelected*/
+      t[17](
+        /*editable*/
+        t[28]
+      )
+    ) && t[17](
+      /*editable*/
+      t[28]
+    ).apply(this, arguments);
+  }), {
+    c() {
+      ft(e.$$.fragment);
+    },
+    m(o, r) {
+      ct(e, o, r), n = !0;
+    },
+    p(o, r) {
+      t = o;
+      const i = {};
+      r[0] & /*drawingEl*/
+      16 && (i.target = /*drawingEl*/
+      t[4]), r[0] & /*editableAnnotations*/
+      64 && (i.editor = we(
+        /*editable*/
+        t[28].target.selector
+      )), r[0] & /*editableAnnotations*/
+      64 && (i.annotation = /*editable*/
+      t[28]), r[0] & /*style*/
+      2 && (i.style = /*style*/
+      t[1]), r[0] & /*transform*/
+      1024 && (i.transform = /*transform*/
+      t[10]), r[0] & /*$scale*/
+      8192 && (i.viewportScale = /*$scale*/
+      t[13]), e.$set(i);
+    },
+    i(o) {
+      n || (V(e.$$.fragment, o), n = !0);
+    },
+    o(o) {
+      k(e.$$.fragment, o), n = !1;
+    },
+    d(o) {
+      ut(e, o);
+    }
+  };
+}
+function Ye(t) {
+  let e = (
+    /*editable*/
+    t[28].id
+  ), n, o, r = Ie(t);
+  return {
+    c() {
+      r.c(), n = at();
+    },
+    m(i, a) {
+      r.m(i, a), B(i, n, a), o = !0;
+    },
+    p(i, a) {
+      a[0] & /*editableAnnotations*/
+      64 && K(e, e = /*editable*/
+      i[28].id) ? (ot(), k(r, 1, 1, U), rt(), r = Ie(i), r.c(), V(r, 1), r.m(n.parentNode, n)) : r.p(i, a);
+    },
+    i(i) {
+      o || (V(r), o = !0);
+    },
+    o(i) {
+      k(r), o = !1;
+    },
+    d(i) {
+      i && L(n), r.d(i);
+    }
+  };
+}
+function Wo(t) {
+  let e, n, o, r, i, a, s = (
+    /*$store*/
+    t[12]
+  ), l = [];
+  for (let c = 0; c < s.length; c += 1)
+    l[c] = Le(Te(t, s, c));
+  const d = (c) => k(l[c], 1, 1, () => {
+    l[c] = null;
+  });
+  let p = (
+    /*drawingEl*/
+    t[4] && Be(t)
+  );
+  return {
+    c() {
+      e = O("svg"), n = O("g");
+      for (let c = 0; c < l.length; c += 1)
+        l[c].c();
+      o = O("g"), p && p.c(), u(o, "class", "drawing"), u(e, "class", "a9s-annotationlayer"), ce(
+        e,
+        "drawing",
+        /*tool*/
+        t[2]
+      );
+    },
+    m(c, f) {
+      B(c, e, f), dt(e, n);
+      for (let h = 0; h < l.length; h += 1)
+        l[h] && l[h].m(n, null);
+      dt(e, o), p && p.m(o, null), t[24](o), t[25](e), r = !0, i || (a = [
+        R(e, "pointerup", function() {
+          H(
+            /*onPointerUp*/
+            t[8]
+          ) && t[8].apply(this, arguments);
+        }),
+        R(e, "pointerdown", function() {
+          H(
+            /*onPointerDown*/
+            t[9]
+          ) && t[9].apply(this, arguments);
+        })
+      ], i = !0);
+    },
+    p(c, f) {
+      if (t = c, f[0] & /*$store, style, isEditable*/
+      4226) {
+        s = /*$store*/
+        t[12];
+        let h;
+        for (h = 0; h < s.length; h += 1) {
+          const m = Te(t, s, h);
+          l[h] ? (l[h].p(m, f), V(l[h], 1)) : (l[h] = Le(m), l[h].c(), V(l[h], 1), l[h].m(n, null));
+        }
+        for (ot(), h = s.length; h < l.length; h += 1)
+          d(h);
+        rt();
+      }
+      t[4] ? p ? (p.p(t, f), f[0] & /*drawingEl*/
+      16 && V(p, 1)) : (p = Be(t), p.c(), V(p, 1), p.m(o, null)) : p && (ot(), k(p, 1, 1, () => {
+        p = null;
+      }), rt()), (!r || f[0] & /*tool*/
+      4) && ce(
+        e,
+        "drawing",
+        /*tool*/
+        t[2]
+      );
+    },
+    i(c) {
+      if (!r) {
+        for (let f = 0; f < s.length; f += 1)
+          V(l[f]);
+        V(p), r = !0;
+      }
+    },
+    o(c) {
+      l = l.filter(Boolean);
+      for (let f = 0; f < l.length; f += 1)
+        k(l[f]);
+      k(p), r = !1;
+    },
+    d(c) {
+      c && L(e), oe(l, c), p && p.d(), t[24](null), t[25](null), i = !1, it(a);
+    }
+  };
+}
+function Ko(t, e, n) {
+  let o, r, i, a, s, l, d, p, c = U, f = () => (c(), c = Ve(b, (I) => n(13, p = I)), b);
+  t.$$.on_destroy.push(() => c());
+  let { drawingEnabled: h } = e, { image: m } = e, { preferredDrawingMode: x } = e, { state: A } = e, { style: $ = void 0 } = e, { tool: y, opts: v } = qe("rectangle"), { tool: E = y, opts: _ = v } = e, { user: C } = e, N, g, b;
+  It(() => f(n(5, b = vo(m, g))));
+  const { selection: w, store: T } = A;
+  de(t, w, (I) => n(23, l = I)), de(t, T, (I) => n(12, d = I));
+  let X = null, P = null;
+  const J = (I) => {
+    T.unobserve(X);
+    const q = I.filter(({ editable: j }) => j).map(({ id: j }) => j);
+    q.length > 0 ? (n(6, P = q.map((j) => T.getAnnotation(j))), X = (j) => {
+      const { updated: G } = j.changes;
+      n(6, P = G.map((st) => st.newValue));
+    }, T.observe(X, { annotations: q })) : n(6, P = null);
+  }, gt = (I) => {
+    const q = Fe(), j = {
+      id: q,
+      bodies: [],
+      target: {
+        annotation: q,
+        selector: I.detail,
+        creator: C,
+        created: /* @__PURE__ */ new Date()
+      }
+    };
+    T.addAnnotation(j), w.setSelected(j.id);
+  }, mt = (I) => (q) => {
+    var j;
+    const { target: G } = I, st = 10 * 60 * 1e3, lt = ((j = G.creator) == null ? void 0 : j.id) !== C.id || !G.created || (/* @__PURE__ */ new Date()).getTime() - G.created.getTime() > st;
+    T.updateTarget({
+      ...G,
+      selector: q.detail,
+      created: lt ? G.created : /* @__PURE__ */ new Date(),
+      updated: lt ? /* @__PURE__ */ new Date() : null,
+      updatedBy: lt ? C : null
+    });
+  };
+  function Tt(I) {
+    Dt[I ? "unshift" : "push"](() => {
+      N = I, n(4, N);
+    });
+  }
+  function W(I) {
+    Dt[I ? "unshift" : "push"](() => {
+      g = I, n(3, g);
+    });
+  }
+  return t.$$set = (I) => {
+    "drawingEnabled" in I && n(0, h = I.drawingEnabled), "image" in I && n(18, m = I.image), "preferredDrawingMode" in I && n(19, x = I.preferredDrawingMode), "state" in I && n(20, A = I.state), "style" in I && n(1, $ = I.style), "tool" in I && n(2, E = I.tool), "opts" in I && n(21, _ = I.opts), "user" in I && n(22, C = I.user);
+  }, t.$$.update = () => {
+    t.$$.dirty[0] & /*opts, preferredDrawingMode*/
+    2621440 && n(11, o = (_ == null ? void 0 : _.drawingMode) || x), t.$$.dirty[0] & /*svgEl*/
+    8 && n(10, r = Do(g)), t.$$.dirty[0] & /*svgEl*/
+    8 && n(9, { onPointerDown: i, onPointerUp: a } = Uo(g, T), i, (n(8, a), n(3, g))), t.$$.dirty[0] & /*$selection*/
+    8388608 && n(7, s = (I) => l.selected.find((q) => q.id === I.id && q.editable)), t.$$.dirty[0] & /*$selection*/
+    8388608 && J(l.selected);
+  }, [
+    h,
+    $,
+    E,
+    g,
+    N,
+    b,
+    P,
+    s,
+    a,
+    i,
+    r,
+    o,
+    d,
+    p,
+    w,
+    T,
+    gt,
+    mt,
+    m,
+    x,
+    A,
+    _,
+    C,
+    l,
+    Tt,
+    W
+  ];
+}
+class Jo extends nt {
+  constructor(e) {
+    super(), et(
+      this,
+      e,
+      Ko,
+      Wo,
+      K,
+      {
+        drawingEnabled: 0,
+        image: 18,
+        preferredDrawingMode: 19,
+        state: 20,
+        style: 1,
+        tool: 2,
+        opts: 21,
+        user: 22
+      },
+      null,
+      [-1, -1]
+    );
+  }
+}
+function Qo(t, e, n, o, r) {
+  We(t, e, n || 0, o || t.length - 1, r || Zo);
+}
+function We(t, e, n, o, r) {
+  for (; o > n; ) {
+    if (o - n > 600) {
+      var i = o - n + 1, a = e - n + 1, s = Math.log(i), l = 0.5 * Math.exp(2 * s / 3), d = 0.5 * Math.sqrt(s * l * (i - l) / i) * (a - i / 2 < 0 ? -1 : 1), p = Math.max(n, Math.floor(e - a * l / i + d)), c = Math.min(o, Math.floor(e + (i - a) * l / i + d));
+      We(t, e, p, c, r);
+    }
+    var f = t[e], h = n, m = o;
+    for (St(t, n, e), r(t[o], f) > 0 && St(t, n, o); h < m; ) {
+      for (St(t, h, m), h++, m--; r(t[h], f) < 0; )
+        h++;
+      for (; r(t[m], f) > 0; )
+        m--;
+    }
+    r(t[n], f) === 0 ? St(t, n, m) : (m++, St(t, m, o)), m <= e && (n = m + 1), e <= m && (o = m - 1);
+  }
+}
+function St(t, e, n) {
+  var o = t[e];
+  t[e] = t[n], t[n] = o;
+}
+function Zo(t, e) {
+  return t < e ? -1 : t > e ? 1 : 0;
+}
+class tr {
+  constructor(e = 9) {
+    this._maxEntries = Math.max(4, e), this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4)), this.clear();
+  }
+  all() {
+    return this._all(this.data, []);
+  }
+  search(e) {
+    let n = this.data;
+    const o = [];
+    if (!kt(e, n))
+      return o;
+    const r = this.toBBox, i = [];
+    for (; n; ) {
+      for (let a = 0; a < n.children.length; a++) {
+        const s = n.children[a], l = n.leaf ? r(s) : s;
+        kt(e, l) && (n.leaf ? o.push(s) : Zt(e, l) ? this._all(s, o) : i.push(s));
+      }
+      n = i.pop();
+    }
+    return o;
+  }
+  collides(e) {
+    let n = this.data;
+    if (!kt(e, n))
+      return !1;
+    const o = [];
+    for (; n; ) {
+      for (let r = 0; r < n.children.length; r++) {
+        const i = n.children[r], a = n.leaf ? this.toBBox(i) : i;
+        if (kt(e, a)) {
+          if (n.leaf || Zt(e, a))
+            return !0;
+          o.push(i);
+        }
+      }
+      n = o.pop();
+    }
+    return !1;
+  }
+  load(e) {
+    if (!(e && e.length))
+      return this;
+    if (e.length < this._minEntries) {
+      for (let o = 0; o < e.length; o++)
+        this.insert(e[o]);
+      return this;
+    }
+    let n = this._build(e.slice(), 0, e.length - 1, 0);
+    if (!this.data.children.length)
+      this.data = n;
+    else if (this.data.height === n.height)
+      this._splitRoot(this.data, n);
+    else {
+      if (this.data.height < n.height) {
+        const o = this.data;
+        this.data = n, n = o;
+      }
+      this._insert(n, this.data.height - n.height - 1, !0);
+    }
+    return this;
+  }
+  insert(e) {
+    return e && this._insert(e, this.data.height - 1), this;
+  }
+  clear() {
+    return this.data = bt([]), this;
+  }
+  remove(e, n) {
+    if (!e)
+      return this;
+    let o = this.data;
+    const r = this.toBBox(e), i = [], a = [];
+    let s, l, d;
+    for (; o || i.length; ) {
+      if (o || (o = i.pop(), l = i[i.length - 1], s = a.pop(), d = !0), o.leaf) {
+        const p = er(e, o.children, n);
+        if (p !== -1)
+          return o.children.splice(p, 1), i.push(o), this._condense(i), this;
+      }
+      !d && !o.leaf && Zt(o, r) ? (i.push(o), a.push(s), s = 0, l = o, o = o.children[0]) : l ? (s++, o = l.children[s], d = !1) : o = null;
+    }
+    return this;
+  }
+  toBBox(e) {
+    return e;
+  }
+  compareMinX(e, n) {
+    return e.minX - n.minX;
+  }
+  compareMinY(e, n) {
+    return e.minY - n.minY;
+  }
+  toJSON() {
+    return this.data;
+  }
+  fromJSON(e) {
+    return this.data = e, this;
+  }
+  _all(e, n) {
+    const o = [];
+    for (; e; )
+      e.leaf ? n.push(...e.children) : o.push(...e.children), e = o.pop();
+    return n;
+  }
+  _build(e, n, o, r) {
+    const i = o - n + 1;
+    let a = this._maxEntries, s;
+    if (i <= a)
+      return s = bt(e.slice(n, o + 1)), wt(s, this.toBBox), s;
+    r || (r = Math.ceil(Math.log(i) / Math.log(a)), a = Math.ceil(i / Math.pow(a, r - 1))), s = bt([]), s.leaf = !1, s.height = r;
+    const l = Math.ceil(i / a), d = l * Math.ceil(Math.sqrt(a));
+    _e(e, n, o, d, this.compareMinX);
+    for (let p = n; p <= o; p += d) {
+      const c = Math.min(p + d - 1, o);
+      _e(e, p, c, l, this.compareMinY);
+      for (let f = p; f <= c; f += l) {
+        const h = Math.min(f + l - 1, c);
+        s.children.push(this._build(e, f, h, r - 1));
+      }
+    }
+    return wt(s, this.toBBox), s;
+  }
+  _chooseSubtree(e, n, o, r) {
+    for (; r.push(n), !(n.leaf || r.length - 1 === o); ) {
+      let i = 1 / 0, a = 1 / 0, s;
+      for (let l = 0; l < n.children.length; l++) {
+        const d = n.children[l], p = Qt(d), c = rr(e, d) - p;
+        c < a ? (a = c, i = p < i ? p : i, s = d) : c === a && p < i && (i = p, s = d);
+      }
+      n = s || n.children[0];
+    }
+    return n;
+  }
+  _insert(e, n, o) {
+    const r = o ? e : this.toBBox(e), i = [], a = this._chooseSubtree(r, this.data, n, i);
+    for (a.children.push(e), Lt(a, r); n >= 0 && i[n].children.length > this._maxEntries; )
+      this._split(i, n), n--;
+    this._adjustParentBBoxes(r, i, n);
+  }
+  // split overflowed node into two
+  _split(e, n) {
+    const o = e[n], r = o.children.length, i = this._minEntries;
+    this._chooseSplitAxis(o, i, r);
+    const a = this._chooseSplitIndex(o, i, r), s = bt(o.children.splice(a, o.children.length - a));
+    s.height = o.height, s.leaf = o.leaf, wt(o, this.toBBox), wt(s, this.toBBox), n ? e[n - 1].children.push(s) : this._splitRoot(o, s);
+  }
+  _splitRoot(e, n) {
+    this.data = bt([e, n]), this.data.height = e.height + 1, this.data.leaf = !1, wt(this.data, this.toBBox);
+  }
+  _chooseSplitIndex(e, n, o) {
+    let r, i = 1 / 0, a = 1 / 0;
+    for (let s = n; s <= o - n; s++) {
+      const l = Mt(e, 0, s, this.toBBox), d = Mt(e, s, o, this.toBBox), p = ir(l, d), c = Qt(l) + Qt(d);
+      p < i ? (i = p, r = s, a = c < a ? c : a) : p === i && c < a && (a = c, r = s);
+    }
+    return r || o - n;
+  }
+  // sorts node children by the best axis for split
+  _chooseSplitAxis(e, n, o) {
+    const r = e.leaf ? this.compareMinX : nr, i = e.leaf ? this.compareMinY : or, a = this._allDistMargin(e, n, o, r), s = this._allDistMargin(e, n, o, i);
+    a < s && e.children.sort(r);
+  }
+  // total margin of all possible split distributions where each node is at least m full
+  _allDistMargin(e, n, o, r) {
+    e.children.sort(r);
+    const i = this.toBBox, a = Mt(e, 0, n, i), s = Mt(e, o - n, o, i);
+    let l = Vt(a) + Vt(s);
+    for (let d = n; d < o - n; d++) {
+      const p = e.children[d];
+      Lt(a, e.leaf ? i(p) : p), l += Vt(a);
+    }
+    for (let d = o - n - 1; d >= n; d--) {
+      const p = e.children[d];
+      Lt(s, e.leaf ? i(p) : p), l += Vt(s);
+    }
+    return l;
+  }
+  _adjustParentBBoxes(e, n, o) {
+    for (let r = o; r >= 0; r--)
+      Lt(n[r], e);
+  }
+  _condense(e) {
+    for (let n = e.length - 1, o; n >= 0; n--)
+      e[n].children.length === 0 ? n > 0 ? (o = e[n - 1].children, o.splice(o.indexOf(e[n]), 1)) : this.clear() : wt(e[n], this.toBBox);
+  }
+}
+function er(t, e, n) {
+  if (!n)
+    return e.indexOf(t);
+  for (let o = 0; o < e.length; o++)
+    if (n(t, e[o]))
+      return o;
+  return -1;
+}
+function wt(t, e) {
+  Mt(t, 0, t.children.length, e, t);
+}
+function Mt(t, e, n, o, r) {
+  r || (r = bt(null)), r.minX = 1 / 0, r.minY = 1 / 0, r.maxX = -1 / 0, r.maxY = -1 / 0;
+  for (let i = e; i < n; i++) {
+    const a = t.children[i];
+    Lt(r, t.leaf ? o(a) : a);
+  }
+  return r;
+}
+function Lt(t, e) {
+  return t.minX = Math.min(t.minX, e.minX), t.minY = Math.min(t.minY, e.minY), t.maxX = Math.max(t.maxX, e.maxX), t.maxY = Math.max(t.maxY, e.maxY), t;
+}
+function nr(t, e) {
+  return t.minX - e.minX;
+}
+function or(t, e) {
+  return t.minY - e.minY;
+}
+function Qt(t) {
+  return (t.maxX - t.minX) * (t.maxY - t.minY);
+}
+function Vt(t) {
+  return t.maxX - t.minX + (t.maxY - t.minY);
+}
+function rr(t, e) {
+  return (Math.max(e.maxX, t.maxX) - Math.min(e.minX, t.minX)) * (Math.max(e.maxY, t.maxY) - Math.min(e.minY, t.minY));
+}
+function ir(t, e) {
+  const n = Math.max(t.minX, e.minX), o = Math.max(t.minY, e.minY), r = Math.min(t.maxX, e.maxX), i = Math.min(t.maxY, e.maxY);
+  return Math.max(0, r - n) * Math.max(0, i - o);
+}
+function Zt(t, e) {
+  return t.minX <= e.minX && t.minY <= e.minY && e.maxX <= t.maxX && e.maxY <= t.maxY;
+}
+function kt(t, e) {
+  return e.minX <= t.maxX && e.minY <= t.maxY && e.maxX >= t.minX && e.maxY >= t.minY;
+}
+function bt(t) {
+  return {
+    children: t,
+    height: 1,
+    leaf: !0,
+    minX: 1 / 0,
+    minY: 1 / 0,
+    maxX: -1 / 0,
+    maxY: -1 / 0
+  };
+}
+function _e(t, e, n, o, r) {
+  const i = [e, n];
+  for (; i.length; ) {
+    if (n = i.pop(), e = i.pop(), n - e <= o)
+      continue;
+    const a = e + Math.ceil((n - e) / o / 2) * o;
+    Qo(t, a, e, n, r), i.push(e, a, a, n);
+  }
+}
+const ar = () => {
+  const t = new tr(), e = /* @__PURE__ */ new Map(), n = () => [...e.values()], o = () => {
+    t.clear(), e.clear();
+  }, r = (a) => {
+    const { minX: s, minY: l, maxX: d, maxY: p } = a.selector.geometry.bounds, c = { minX: s, minY: l, maxX: d, maxY: p, target: a };
+    t.insert(c), e.set(a.annotation, c);
+  }, i = (a) => {
+    const s = e.get(a.annotation);
+    t.remove(s), e.delete(a.annotation);
+  };
+  return {
+    all: n,
+    clear: o,
+    getAt: (a, s) => {
+      const l = t.search({
+        minX: a,
+        minY: s,
+        maxX: a,
+        maxY: s
+      }).map((d) => d.target).filter((d) => d.selector.type === F.RECTANGLE || cn(d.selector, a, s));
+      if (l.length > 0)
+        return l.sort((d, p) => ne(d.selector) - ne(p.selector)), l[0];
+    },
+    getIntersecting: (a, s, l, d) => t.search({
+      minX: a,
+      minY: s,
+      maxX: a + l,
+      maxY: s + d
+    }).map((p) => p.target),
+    insert: r,
+    remove: i,
+    set: (a, s = !0) => {
+      s && o();
+      const l = a.map((d) => {
+        const { minX: p, minY: c, maxX: f, maxY: h } = d.selector.geometry.bounds;
+        return { minX: p, minY: c, maxX: f, maxY: h, target: d };
+      });
+      l.forEach((d) => e.set(d.target.annotation, d)), t.load(l);
+    },
+    size: () => t.all().length,
+    update: (a, s) => {
+      i(a), r(s);
+    }
+  };
+}, sr = (t) => {
+  const e = On(), n = ar(), o = Mn(e, t.pointerSelectAction), r = Sn(e), i = Gn();
+  return e.observe(({ changes: a }) => {
+    n.set(a.created.map((s) => s.target), !1), a.deleted.forEach((s) => n.remove(s.target)), a.updated.forEach(({ oldValue: s, newValue: l }) => n.update(s.target, l.target));
+  }), {
+    store: {
+      ...e,
+      getAt: (a, s) => {
+        const l = n.getAt(a, s);
+        return l ? e.getAnnotation(l.annotation) : void 0;
+      },
+      getIntersecting: (a, s, l, d) => n.getIntersecting(a, s, l, d).map((p) => e.getAnnotation(p.annotation))
+    },
+    selection: o,
+    hover: r,
+    viewport: i
+  };
+}, lr = (t) => {
+  const e = sr(t);
+  return {
+    ...e,
+    store: Vn(e.store)
+  };
+}, dr = (t) => {
+  let e, n;
+  if (t.nodeName === "CANVAS")
+    e = t, n = e.getContext("2d", { willReadFrequently: !0 });
+  else {
+    const r = t;
+    e = document.createElement("canvas"), e.width = r.width, e.height = r.height, n = e.getContext("2d", { willReadFrequently: !0 }), n.drawImage(r, 0, 0, r.width, r.height);
+  }
+  let o = 0;
+  for (let r = 1; r < 10; r++)
+    for (let i = 1; i < 10; i++) {
+      const a = Math.round(i * e.width / 10), s = Math.round(r * e.height / 10), l = n.getImageData(a, s, 1, 1).data, d = (0.299 * l[0] + 0.587 * l[1] + 0.114 * l[2]) / 255;
+      o += d;
+    }
+  return o / 81;
+}, cr = (t) => {
+  const e = dr(t), n = e > 0.6 ? "dark" : "light";
+  return console.log(`[Annotorious] Image brightness: ${e.toFixed(1)}. Setting ${n} theme.`), n;
+}, Ce = (t, e, n) => e.setAttribute("data-theme", n === "auto" ? cr(t) : n), ur = (t) => ({
+  ...t,
+  drawingEnabled: t.drawingEnabled === void 0 ? !0 : t.drawingEnabled,
+  drawingMode: t.drawingMode || "drag",
+  pointerSelectAction: t.pointerSelectAction || He.EDIT,
+  theme: t.theme || "light"
+}), Pe = navigator.userAgent.indexOf("Mac OS X") !== -1, hr = (t, e) => {
+  const n = e || document, o = (a) => {
+    a.key === "Z" && a.ctrlKey ? t.undo() : a.key === "Y" && a.ctrlKey && t.redo();
+  }, r = (a) => {
+    a.key === "z" && a.metaKey && (a.shiftKey ? t.redo() : t.undo());
+  }, i = () => {
+    Pe ? n.removeEventListener("keydown", r) : n.removeEventListener("keydown", o);
+  };
+  return Pe ? n.addEventListener("keydown", r) : n.addEventListener("keydown", o), {
+    destroy: i
+  };
+}, fr = (t, e = {}) => {
+  if (!t)
+    throw "Missing argument: image";
+  const n = typeof t == "string" ? document.getElementById(t) : t, o = ur(e), r = lr(o), { selection: i, store: a } = r, s = Dn(a), l = Un(
+    r,
+    s,
+    o.adapter,
+    o.autoSave
+  ), d = document.createElement("DIV");
+  d.style.position = "relative", d.style.display = "inline-block", n.style.display = "block", n.parentNode.insertBefore(d, n), d.appendChild(n);
+  const p = hr(s);
+  let c = Wn();
+  Ce(n, d, o.theme);
+  const f = new Jo({
+    target: d,
+    props: {
+      drawingEnabled: o.drawingEnabled,
+      image: n,
+      preferredDrawingMode: o.drawingMode,
+      state: r,
+      style: o.style,
+      user: c
+    }
+  });
+  f.$on("click", (g) => {
+    const { originalEvent: b, annotation: w } = g.detail;
+    w ? i.clickSelect(w.id, b) : i.isEmpty() || i.clear();
+  });
+  const h = Hn(r, s, o.adapter), m = () => {
+    f.$destroy(), d.parentNode.insertBefore(n, d), d.parentNode.removeChild(d), p.destroy(), s.destroy();
+  }, x = () => c, A = (g, b, w) => Lo(g, b, w), $ = (g, b) => co(g, b), y = (g) => {
+    const { tool: b, opts: w } = qe(g);
+    f.$set({ tool: b, opts: w });
+  }, v = (g) => f.$set({ drawingEnabled: g }), E = (g) => {
+    console.warn("Filter not implemented yet");
+  }, _ = (g) => f.$set({ style: g }), C = (g) => Ce(n, d, g), N = (g) => {
+    c = g, f.$set({ user: g });
+  };
+  return {
+    ...h,
+    destroy: m,
+    getUser: x,
+    listDrawingTools: Mo,
+    on: l.on,
+    off: l.off,
+    registerDrawingTool: A,
+    registerShapeEditor: $,
+    setDrawingEnabled: v,
+    setDrawingTool: y,
+    setFilter: E,
+    setStyle: _,
+    setTheme: C,
+    setUser: N,
+    state: r
+  };
+};
 export {
-  e as __module
+  Re as Editor,
+  go as EditorMount,
+  M as Handle,
+  D as Origin,
+  He as PointerSelectAction,
+  ro as PolygonEditor,
+  lo as RectangleEditor,
+  pn as RectangleUtil,
+  xo as RubberbandRectangle,
+  Jo as SVGAnnotationLayer,
+  F as ShapeType,
+  yo as ToolMount,
+  pr as W3CImageFormat,
+  Uo as addEventListeners,
+  Gt as boundsFromPoints,
+  ne as computeArea,
+  Wn as createAnonymousGuest,
+  Hn as createBaseAnnotator,
+  fr as createImageAnnotator,
+  sr as createImageAnnotatorState,
+  Do as createSVGTransform,
+  lr as createSvelteImageAnnotatorState,
+  cr as detectTheme,
+  je as diffAnnotations,
+  Wt as distance,
+  vo as enableResponsive,
+  ur as fillDefaults,
+  we as getEditor,
+  qe as getTool,
+  hr as initKeyboardCommands,
+  cn as intersects,
+  Mo as listDrawingTools,
+  Fn as parseAll,
+  fn as parseFragmentSelector,
+  xn as parseSVGSelector,
+  Jn as parseW3CBodies,
+  Zn as parseW3CImageAnnotation,
+  co as registerEditor,
+  ie as registerShapeUtil,
+  Lo as registerTool,
+  dr as sampleBrightness,
+  gn as serializeFragmentSelector,
+  bn as serializeSVGSelector,
+  Qn as serializeW3CBodies,
+  to as serializeW3CImageAnnotation,
+  Ce as setTheme
 };
 //# sourceMappingURL=annotorious-react.es18.js.map