@annotorious/annotorious 3.0.0-rc.1

package/dist/annotorious.es.js

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