@annotorious/svelte 3.0.0-rc.2 → 3.0.0-rc.21

package/dist/annotorious-svelte.es4.js

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