@annotorious/react-manifold 3.0.0-rc.18 → 3.0.0-rc.19.1

package/dist/annotorious-react-manifold.es9.js

@@ -1,602 +1,1389 @@
-import { __exports as R } from "./annotorious-react-manifold.es11.js";
-import tr from "react";
-/**
- * @license React
- * react-jsx-runtime.development.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-var he;
-function ir() {
-  return he ? R : (he = 1, process.env.NODE_ENV !== "production" && function() {
-    var Ee = tr, x = Symbol.for("react.element"), ye = Symbol.for("react.portal"), _ = Symbol.for("react.fragment"), U = Symbol.for("react.strict_mode"), N = Symbol.for("react.profiler"), B = Symbol.for("react.provider"), q = Symbol.for("react.context"), T = Symbol.for("react.forward_ref"), k = Symbol.for("react.suspense"), D = Symbol.for("react.suspense_list"), C = Symbol.for("react.memo"), F = Symbol.for("react.lazy"), me = Symbol.for("react.offscreen"), G = Symbol.iterator, Re = "@@iterator";
-    function _e(e) {
-      if (e === null || typeof e != "object")
-        return null;
-      var r = G && e[G] || e[Re];
-      return typeof r == "function" ? r : null;
-    }
-    var b = Ee.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-    function l(e) {
-      {
-        for (var r = arguments.length, t = new Array(r > 1 ? r - 1 : 0), n = 1; n < r; n++)
-          t[n - 1] = arguments[n];
-        Te("error", e, t);
-      }
-    }
-    function Te(e, r, t) {
-      {
-        var n = b.ReactDebugCurrentFrame, o = n.getStackAddendum();
-        o !== "" && (r += "%s", t = t.concat([o]));
-        var u = t.map(function(i) {
-          return String(i);
-        });
-        u.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, u);
-      }
-    }
-    var Ce = !1, Pe = !1, we = !1, Oe = !1, Se = !1, z;
-    z = Symbol.for("react.module.reference");
-    function je(e) {
-      return !!(typeof e == "string" || typeof e == "function" || e === _ || e === N || Se || e === U || e === k || e === D || Oe || e === me || Ce || Pe || we || typeof e == "object" && e !== null && (e.$$typeof === F || e.$$typeof === C || e.$$typeof === B || e.$$typeof === q || e.$$typeof === T || // This needs to include all possible module reference object
-      // types supported by any Flight configuration anywhere since
-      // we don't know which Flight build this will end up being used
-      // with.
-      e.$$typeof === z || e.getModuleId !== void 0));
-    }
-    function xe(e, r, t) {
-      var n = e.displayName;
-      if (n)
-        return n;
-      var o = r.displayName || r.name || "";
-      return o !== "" ? t + "(" + o + ")" : t;
-    }
-    function J(e) {
-      return e.displayName || "Context";
-    }
-    function d(e) {
-      if (e == null)
-        return null;
-      if (typeof e.tag == "number" && l("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
-        return e.displayName || e.name || null;
-      if (typeof e == "string")
-        return e;
-      switch (e) {
-        case _:
-          return "Fragment";
-        case ye:
-          return "Portal";
-        case N:
-          return "Profiler";
-        case U:
-          return "StrictMode";
-        case k:
-          return "Suspense";
-        case D:
-          return "SuspenseList";
-      }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
-          case q:
-            var r = e;
-            return J(r) + ".Consumer";
-          case B:
-            var t = e;
-            return J(t._context) + ".Provider";
-          case T:
-            return xe(e, e.render, "ForwardRef");
-          case C:
-            var n = e.displayName || null;
-            return n !== null ? n : d(e.type) || "Memo";
-          case F: {
-            var o = e, u = o._payload, i = o._init;
-            try {
-              return d(i(u));
-            } catch {
-              return null;
-            }
-          }
-        }
-      return null;
-    }
-    var g = Object.assign, y = 0, K, H, X, Z, Q, ee, re;
-    function te() {
-    }
-    te.__reactDisabledLog = !0;
-    function ke() {
-      {
-        if (y === 0) {
-          K = console.log, H = console.info, X = console.warn, Z = console.error, Q = console.group, ee = console.groupCollapsed, re = console.groupEnd;
-          var e = {
-            configurable: !0,
-            enumerable: !0,
-            value: te,
-            writable: !0
-          };
-          Object.defineProperties(console, {
-            info: e,
-            log: e,
-            warn: e,
-            error: e,
-            group: e,
-            groupCollapsed: e,
-            groupEnd: e
-          });
-        }
-        y++;
-      }
+var Qt = Object.defineProperty, Wt = (t, n, o) => n in t ? Qt(t, n, { enumerable: !0, configurable: !0, writable: !0, value: o }) : t[n] = o, Mt = (t, n, o) => (Wt(t, typeof n != "symbol" ? n + "" : n, o), o);
+function nt() {
+}
+function Ot(t, n) {
+  for (const o in n)
+    t[o] = n[o];
+  return (
+    /** @type {T & S} */
+    t
+  );
+}
+function Xt(t) {
+  return t();
+}
+function At() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function F(t) {
+  t.forEach(Xt);
+}
+function _(t) {
+  return typeof t == "function";
+}
+function dt(t, n) {
+  return t != t ? n == n : t !== n || t && typeof t == "object" || typeof t == "function";
+}
+function Jt(t) {
+  return Object.keys(t).length === 0;
+}
+function Zt(t, n, o, r) {
+  if (t) {
+    const e = Dt(t, n, o, r);
+    return t[0](e);
+  }
+}
+function Dt(t, n, o, r) {
+  return t[1] && r ? Ot(o.ctx.slice(), t[1](r(n))) : o.ctx;
+}
+function vt(t, n, o, r) {
+  if (t[2] && r) {
+    const e = t[2](r(o));
+    if (n.dirty === void 0)
+      return e;
+    if (typeof e == "object") {
+      const a = [], c = Math.max(n.dirty.length, e.length);
+      for (let i = 0; i < c; i += 1)
+        a[i] = n.dirty[i] | e[i];
+      return a;
     }
-    function De() {
-      {
-        if (y--, y === 0) {
-          var e = {
-            configurable: !0,
-            enumerable: !0,
-            writable: !0
-          };
-          Object.defineProperties(console, {
-            log: g({}, e, {
-              value: K
-            }),
-            info: g({}, e, {
-              value: H
-            }),
-            warn: g({}, e, {
-              value: X
-            }),
-            error: g({}, e, {
-              value: Z
-            }),
-            group: g({}, e, {
-              value: Q
-            }),
-            groupCollapsed: g({}, e, {
-              value: ee
-            }),
-            groupEnd: g({}, e, {
-              value: re
-            })
-          });
-        }
-        y < 0 && l("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
-      }
+    return n.dirty | e;
+  }
+  return n.dirty;
+}
+function Yt(t, n, o, r, e, a) {
+  if (e) {
+    const c = Dt(n, o, r, a);
+    t.p(c, e);
+  }
+}
+function tn(t) {
+  if (t.ctx.length > 32) {
+    const n = [], o = t.ctx.length / 32;
+    for (let r = 0; r < o; r++)
+      n[r] = -1;
+    return n;
+  }
+  return -1;
+}
+function Ht(t) {
+  const n = {};
+  for (const o in t)
+    o[0] !== "$" && (n[o] = t[o]);
+  return n;
+}
+function ht(t) {
+  return t ?? "";
+}
+function It(t, n) {
+  t.appendChild(n);
+}
+function E(t, n, o) {
+  t.insertBefore(n, o || null);
+}
+function b(t) {
+  t.parentNode && t.parentNode.removeChild(t);
+}
+function nn(t, n) {
+  for (let o = 0; o < t.length; o += 1)
+    t[o] && t[o].d(n);
+}
+function M(t) {
+  return document.createElementNS("http://www.w3.org/2000/svg", t);
+}
+function zt(t) {
+  return document.createTextNode(t);
+}
+function k() {
+  return zt(" ");
+}
+function qt() {
+  return zt("");
+}
+function P(t, n, o, r) {
+  return t.addEventListener(n, o, r), () => t.removeEventListener(n, o, r);
+}
+function s(t, n, o) {
+  o == null ? t.removeAttribute(n) : t.getAttribute(n) !== o && t.setAttribute(n, o);
+}
+function on(t) {
+  return Array.from(t.childNodes);
+}
+function kt(t, n, o) {
+  t.classList.toggle(n, !!o);
+}
+function rn(t, n, { bubbles: o = !1, cancelable: r = !1 } = {}) {
+  return new CustomEvent(t, { detail: n, bubbles: o, cancelable: r });
+}
+let ot;
+function tt(t) {
+  ot = t;
+}
+function en() {
+  if (!ot)
+    throw new Error("Function called outside component initialization");
+  return ot;
+}
+function sn() {
+  const t = en();
+  return (n, o, { cancelable: r = !1 } = {}) => {
+    const e = t.$$.callbacks[n];
+    if (e) {
+      const a = rn(
+        /** @type {string} */
+        n,
+        o,
+        { cancelable: r }
+      );
+      return e.slice().forEach((c) => {
+        c.call(t, a);
+      }), !a.defaultPrevented;
     }
-    var A = b.ReactCurrentDispatcher, I;
-    function P(e, r, t) {
-      {
-        if (I === void 0)
-          try {
-            throw Error();
-          } catch (o) {
-            var n = o.stack.trim().match(/\n( *(at )?)/);
-            I = n && n[1] || "";
-          }
-        return `
-` + I + e;
+    return !0;
+  };
+}
+function R(t, n) {
+  const o = t.$$.callbacks[n.type];
+  o && o.slice().forEach((r) => r.call(this, n));
+}
+const J = [], Gt = [];
+let Z = [];
+const Nt = [], an = /* @__PURE__ */ Promise.resolve();
+let St = !1;
+function cn() {
+  St || (St = !0, an.then(Vt));
+}
+function Pt(t) {
+  Z.push(t);
+}
+const Et = /* @__PURE__ */ new Set();
+let W = 0;
+function Vt() {
+  if (W !== 0)
+    return;
+  const t = ot;
+  do {
+    try {
+      for (; W < J.length; ) {
+        const n = J[W];
+        W++, tt(n), ln(n.$$);
       }
+    } catch (n) {
+      throw J.length = 0, W = 0, n;
     }
-    var W = !1, w;
-    {
-      var Fe = typeof WeakMap == "function" ? WeakMap : Map;
-      w = new Fe();
+    for (tt(null), J.length = 0, W = 0; Gt.length; )
+      Gt.pop()();
+    for (let n = 0; n < Z.length; n += 1) {
+      const o = Z[n];
+      Et.has(o) || (Et.add(o), o());
     }
-    function ne(e, r) {
-      if (!e || W)
-        return "";
-      {
-        var t = w.get(e);
-        if (t !== void 0)
-          return t;
-      }
-      var n;
-      W = !0;
-      var o = Error.prepareStackTrace;
-      Error.prepareStackTrace = void 0;
-      var u;
-      u = A.current, A.current = null, ke();
-      try {
-        if (r) {
-          var i = function() {
-            throw Error();
-          };
-          if (Object.defineProperty(i.prototype, "props", {
-            set: function() {
-              throw Error();
-            }
-          }), typeof Reflect == "object" && Reflect.construct) {
-            try {
-              Reflect.construct(i, []);
-            } catch (p) {
-              n = p;
-            }
-            Reflect.construct(e, [], i);
-          } else {
-            try {
-              i.call();
-            } catch (p) {
-              n = p;
-            }
-            e.call(i.prototype);
-          }
-        } else {
-          try {
-            throw Error();
-          } catch (p) {
-            n = p;
-          }
-          e();
-        }
-      } catch (p) {
-        if (p && n && typeof p.stack == "string") {
-          for (var a = p.stack.split(`
-`), c = n.stack.split(`
-`), s = a.length - 1, f = c.length - 1; s >= 1 && f >= 0 && a[s] !== c[f]; )
-            f--;
-          for (; s >= 1 && f >= 0; s--, f--)
-            if (a[s] !== c[f]) {
-              if (s !== 1 || f !== 1)
-                do
-                  if (s--, f--, f < 0 || a[s] !== c[f]) {
-                    var v = `
-` + a[s].replace(" at new ", " at ");
-                    return e.displayName && v.includes("<anonymous>") && (v = v.replace("<anonymous>", e.displayName)), typeof e == "function" && w.set(e, v), v;
-                  }
-                while (s >= 1 && f >= 0);
-              break;
-            }
-        }
-      } finally {
-        W = !1, A.current = u, De(), Error.prepareStackTrace = o;
-      }
-      var E = e ? e.displayName || e.name : "", be = E ? P(E) : "";
-      return typeof e == "function" && w.set(e, be), be;
+    Z.length = 0;
+  } while (J.length);
+  for (; Nt.length; )
+    Nt.pop()();
+  St = !1, Et.clear(), tt(t);
+}
+function ln(t) {
+  if (t.fragment !== null) {
+    t.update(), F(t.before_update);
+    const n = t.dirty;
+    t.dirty = [-1], t.fragment && t.fragment.p(t.ctx, n), t.after_update.forEach(Pt);
+  }
+}
+function un(t) {
+  const n = [], o = [];
+  Z.forEach((r) => t.indexOf(r) === -1 ? n.push(r) : o.push(r)), o.forEach((r) => r()), Z = n;
+}
+const ft = /* @__PURE__ */ new Set();
+let K;
+function pn() {
+  K = {
+    r: 0,
+    c: [],
+    p: K
+    // parent group
+  };
+}
+function fn() {
+  K.r || F(K.c), K = K.p;
+}
+function H(t, n) {
+  t && t.i && (ft.delete(t), t.i(n));
+}
+function G(t, n, o, r) {
+  if (t && t.o) {
+    if (ft.has(t))
+      return;
+    ft.add(t), K.c.push(() => {
+      ft.delete(t), r && (o && t.d(1), r());
+    }), t.o(n);
+  } else
+    r && r();
+}
+function Rt(t) {
+  return (t == null ? void 0 : t.length) !== void 0 ? t : Array.from(t);
+}
+function Q(t) {
+  t && t.c();
+}
+function D(t, n, o) {
+  const { fragment: r, after_update: e } = t.$$;
+  r && r.m(n, o), Pt(() => {
+    const a = t.$$.on_mount.map(Xt).filter(_);
+    t.$$.on_destroy ? t.$$.on_destroy.push(...a) : F(a), t.$$.on_mount = [];
+  }), e.forEach(Pt);
+}
+function z(t, n) {
+  const o = t.$$;
+  o.fragment !== null && (un(o.after_update), F(o.on_destroy), o.fragment && o.fragment.d(n), o.on_destroy = o.fragment = null, o.ctx = []);
+}
+function hn(t, n) {
+  t.$$.dirty[0] === -1 && (J.push(t), cn(), t.$$.dirty.fill(0)), t.$$.dirty[n / 31 | 0] |= 1 << n % 31;
+}
+function gt(t, n, o, r, e, a, c = null, i = [-1]) {
+  const l = ot;
+  tt(t);
+  const h = t.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props: a,
+    update: nt,
+    not_equal: e,
+    bound: At(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(n.context || (l ? l.$$.context : [])),
+    // everything else
+    callbacks: At(),
+    dirty: i,
+    skip_bound: !1,
+    root: n.target || l.$$.root
+  };
+  c && c(h.root);
+  let d = !1;
+  if (h.ctx = o ? o(t, n.props || {}, ($, u, ...y) => {
+    const g = y.length ? y[0] : u;
+    return h.ctx && e(h.ctx[$], h.ctx[$] = g) && (!h.skip_bound && h.bound[$] && h.bound[$](g), d && hn(t, $)), u;
+  }) : [], h.update(), d = !0, F(h.before_update), h.fragment = r ? r(h.ctx) : !1, n.target) {
+    if (n.hydrate) {
+      const $ = on(n.target);
+      h.fragment && h.fragment.l($), $.forEach(b);
+    } else
+      h.fragment && h.fragment.c();
+    n.intro && H(t.$$.fragment), D(t, n.target, n.anchor), Vt();
+  }
+  tt(l);
+}
+class yt {
+  constructor() {
+    Mt(this, "$$"), Mt(this, "$$set");
+  }
+  /** @returns {void} */
+  $destroy() {
+    z(this, 1), this.$destroy = nt;
+  }
+  /**
+   * @template {Extract<keyof Events, string>} K
+   * @param {K} type
+   * @param {((e: Events[K]) => void) | null | undefined} callback
+   * @returns {() => void}
+   */
+  $on(n, o) {
+    if (!_(o))
+      return nt;
+    const r = this.$$.callbacks[n] || (this.$$.callbacks[n] = []);
+    return r.push(o), () => {
+      const e = r.indexOf(o);
+      e !== -1 && r.splice(e, 1);
+    };
+  }
+  /**
+   * @param {Partial<Props>} props
+   * @returns {void}
+   */
+  $set(n) {
+    this.$$set && !Jt(n) && (this.$$.skip_bound = !0, this.$$set(n), this.$$.skip_bound = !1);
+  }
+}
+const dn = "4";
+typeof window < "u" && (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(dn);
+var v = /* @__PURE__ */ ((t) => (t.ELLIPSE = "ELLIPSE", t.POLYGON = "POLYGON", t.RECTANGLE = "RECTANGLE", t))(v || {});
+const Lt = (t, n) => n, gn = (t) => {
+  let n = 1 / 0, o = 1 / 0, r = -1 / 0, e = -1 / 0;
+  return t.forEach(([a, c]) => {
+    n = Math.min(n, a), o = Math.min(o, c), r = Math.max(r, a), e = Math.max(e, c);
+  }), { minX: n, minY: o, maxX: r, maxY: e };
+}, yn = {
+  area: (t) => Math.PI * t.geometry.rx * t.geometry.ry,
+  intersects: (t, n, o) => {
+    const { cx: r, cy: e, rx: a, ry: c } = t.geometry, i = 0, l = Math.cos(i), h = Math.sin(i), d = n - r, $ = o - e, u = l * d + h * $, y = h * d - l * $;
+    return u * u / (a * a) + y * y / (c * c) <= 1;
+  }
+};
+Lt(v.ELLIPSE, yn);
+const mn = {
+  area: (t) => {
+    const { points: n } = t.geometry;
+    let o = 0, r = n.length - 1;
+    for (let e = 0; e < n.length; e++)
+      o += (n[r][0] + n[e][0]) * (n[r][1] - n[e][1]), r = e;
+    return Math.abs(0.5 * o);
+  },
+  intersects: (t, n, o) => {
+    const { points: r } = t.geometry;
+    let e = !1;
+    for (let a = 0, c = r.length - 1; a < r.length; c = a++) {
+      const i = r[a][0], l = r[a][1], h = r[c][0], d = r[c][1];
+      l > o != d > o && n < (h - i) * (o - l) / (d - l) + i && (e = !e);
     }
-    function Ae(e, r, t) {
-      return ne(e, !1);
+    return e;
+  }
+};
+Lt(v.POLYGON, mn);
+const $n = {
+  area: (t) => t.geometry.w * t.geometry.h,
+  intersects: (t, n, o) => n >= t.geometry.x && n <= t.geometry.x + t.geometry.w && o >= t.geometry.y && o <= t.geometry.y + t.geometry.h
+};
+Lt(v.RECTANGLE, $n);
+const xn = [];
+for (let t = 0; t < 256; ++t)
+  xn.push((t + 256).toString(16).slice(1));
+typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+const wn = [];
+for (let t = 0; t < 256; ++t)
+  wn.push((t + 256).toString(16).slice(1));
+typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+let Tn = (t = 21) => crypto.getRandomValues(new Uint8Array(t)).reduce((n, o) => (o &= 63, o < 36 ? n += o.toString(36) : o < 62 ? n += (o - 26).toString(36).toUpperCase() : o > 62 ? n += "-" : n += "_", n), "");
+Tn();
+function Ft(t, n, o) {
+  const r = t.slice();
+  return r[10] = n[o], r[12] = o, r;
+}
+function Bt(t) {
+  let n, o;
+  return n = new Y({
+    props: {
+      x: (
+        /*point*/
+        t[10][0]
+      ),
+      y: (
+        /*point*/
+        t[10][1]
+      ),
+      scale: (
+        /*viewportScale*/
+        t[3]
+      )
     }
-    function Ie(e) {
-      var r = e.prototype;
-      return !!(r && r.isReactComponent);
+  }), n.$on("pointerdown", function() {
+    _(
+      /*grab*/
+      t[9](`HANDLE-${/*idx*/
+      t[12]}`)
+    ) && t[9](`HANDLE-${/*idx*/
+    t[12]}`).apply(this, arguments);
+  }), {
+    c() {
+      Q(n.$$.fragment);
+    },
+    m(r, e) {
+      D(n, r, e), o = !0;
+    },
+    p(r, e) {
+      t = r;
+      const a = {};
+      e & /*geom*/
+      16 && (a.x = /*point*/
+      t[10][0]), e & /*geom*/
+      16 && (a.y = /*point*/
+      t[10][1]), e & /*viewportScale*/
+      8 && (a.scale = /*viewportScale*/
+      t[3]), n.$set(a);
+    },
+    i(r) {
+      o || (H(n.$$.fragment, r), o = !0);
+    },
+    o(r) {
+      G(n.$$.fragment, r), o = !1;
+    },
+    d(r) {
+      z(n, r);
     }
-    function O(e, r, t) {
-      if (e == null)
-        return "";
-      if (typeof e == "function")
-        return ne(e, Ie(e));
-      if (typeof e == "string")
-        return P(e);
-      switch (e) {
-        case k:
-          return P("Suspense");
-        case D:
-          return P("SuspenseList");
-      }
-      if (typeof e == "object")
-        switch (e.$$typeof) {
-          case T:
-            return Ae(e.render);
-          case C:
-            return O(e.type, r, t);
-          case F: {
-            var n = e, o = n._payload, u = n._init;
-            try {
-              return O(u(o), r, t);
-            } catch {
-            }
-          }
+  };
+}
+function bn(t) {
+  let n, o, r, e, a, c, i, l, h, d, $, u = Rt(
+    /*geom*/
+    t[4].points
+  ), y = [];
+  for (let p = 0; p < u.length; p += 1)
+    y[p] = Bt(Ft(t, u, p));
+  const g = (p) => G(y[p], 1, 1, () => {
+    y[p] = null;
+  });
+  return {
+    c() {
+      n = M("polygon"), e = k(), a = M("polygon"), i = k();
+      for (let p = 0; p < y.length; p += 1)
+        y[p].c();
+      l = qt(), s(n, "class", "a9s-outer"), s(n, "style", o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), s(n, "points", r = /*geom*/
+      t[4].points.map(Ut).join(" ")), s(a, "class", "a9s-inner a9s-shape-handle"), s(
+        a,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), s(a, "points", c = /*geom*/
+      t[4].points.map(jt).join(" "));
+    },
+    m(p, m) {
+      E(p, n, m), E(p, e, m), E(p, a, m), E(p, i, m);
+      for (let w = 0; w < y.length; w += 1)
+        y[w] && y[w].m(p, m);
+      E(p, l, m), h = !0, d || ($ = [
+        P(n, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("SHAPE")
+          ) && t[9]("SHAPE").apply(this, arguments);
+        }),
+        P(a, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("SHAPE")
+          ) && t[9]("SHAPE").apply(this, arguments);
+        })
+      ], d = !0);
+    },
+    p(p, m) {
+      if (t = p, (!h || m & /*computedStyle*/
+      2 && o !== (o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0)) && s(n, "style", o), (!h || m & /*geom*/
+      16 && r !== (r = /*geom*/
+      t[4].points.map(Ut).join(" "))) && s(n, "points", r), (!h || m & /*computedStyle*/
+      2) && s(
+        a,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), (!h || m & /*geom*/
+      16 && c !== (c = /*geom*/
+      t[4].points.map(jt).join(" "))) && s(a, "points", c), m & /*geom, viewportScale, grab*/
+      536) {
+        u = Rt(
+          /*geom*/
+          t[4].points
+        );
+        let w;
+        for (w = 0; w < u.length; w += 1) {
+          const S = Ft(t, u, w);
+          y[w] ? (y[w].p(S, m), H(y[w], 1)) : (y[w] = Bt(S), y[w].c(), H(y[w], 1), y[w].m(l.parentNode, l));
         }
-      return "";
-    }
-    var S = Object.prototype.hasOwnProperty, ae = {}, ie = b.ReactDebugCurrentFrame;
-    function j(e) {
-      if (e) {
-        var r = e._owner, t = O(e.type, e._source, r ? r.type : null);
-        ie.setExtraStackFrame(t);
-      } else
-        ie.setExtraStackFrame(null);
-    }
-    function We(e, r, t, n, o) {
-      {
-        var u = Function.call.bind(S);
-        for (var i in e)
-          if (u(e, i)) {
-            var a = void 0;
-            try {
-              if (typeof e[i] != "function") {
-                var c = Error((n || "React class") + ": " + t + " type `" + i + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[i] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
-                throw c.name = "Invariant Violation", c;
-              }
-              a = e[i](r, i, n, t, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
-            } catch (s) {
-              a = s;
-            }
-            a && !(a instanceof Error) && (j(o), l("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", n || "React class", t, i, typeof a), j(null)), a instanceof Error && !(a.message in ae) && (ae[a.message] = !0, j(o), l("Failed %s type: %s", t, a.message), j(null));
-          }
-      }
-    }
-    var $e = Array.isArray;
-    function $(e) {
-      return $e(e);
-    }
-    function Ye(e) {
-      {
-        var r = typeof Symbol == "function" && Symbol.toStringTag, t = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
-        return t;
+        for (pn(), w = u.length; w < y.length; w += 1)
+          g(w);
+        fn();
       }
-    }
-    function Me(e) {
-      try {
-        return oe(e), !1;
-      } catch {
-        return !0;
+    },
+    i(p) {
+      if (!h) {
+        for (let m = 0; m < u.length; m += 1)
+          H(y[m]);
+        h = !0;
       }
+    },
+    o(p) {
+      y = y.filter(Boolean);
+      for (let m = 0; m < y.length; m += 1)
+        G(y[m]);
+      h = !1;
+    },
+    d(p) {
+      p && (b(n), b(e), b(a), b(i), b(l)), nn(y, p), d = !1, F($);
     }
-    function oe(e) {
-      return "" + e;
+  };
+}
+function En(t) {
+  let n, o;
+  return n = new Kt({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          bn,
+          ({ grab: r }) => ({ 9: r }),
+          ({ grab: r }) => r ? 512 : 0
+        ]
+      },
+      $$scope: { ctx: t }
     }
-    function ue(e) {
-      if (Me(e))
-        return l("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ye(e)), oe(e);
+  }), n.$on(
+    "change",
+    /*change_handler*/
+    t[6]
+  ), n.$on(
+    "grab",
+    /*grab_handler*/
+    t[7]
+  ), n.$on(
+    "release",
+    /*release_handler*/
+    t[8]
+  ), {
+    c() {
+      Q(n.$$.fragment);
+    },
+    m(r, e) {
+      D(n, r, e), o = !0;
+    },
+    p(r, [e]) {
+      const a = {};
+      e & /*shape*/
+      1 && (a.shape = /*shape*/
+      r[0]), e & /*transform*/
+      4 && (a.transform = /*transform*/
+      r[2]), e & /*$$scope, geom, viewportScale, grab, computedStyle*/
+      8730 && (a.$$scope = { dirty: e, ctx: r }), n.$set(a);
+    },
+    i(r) {
+      o || (H(n.$$.fragment, r), o = !0);
+    },
+    o(r) {
+      G(n.$$.fragment, r), o = !1;
+    },
+    d(r) {
+      z(n, r);
     }
-    var m = b.ReactCurrentOwner, Ve = {
-      key: !0,
-      ref: !0,
-      __self: !0,
-      __source: !0
-    }, se, fe, Y;
-    Y = {};
-    function Le(e) {
-      if (S.call(e, "ref")) {
-        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
-        if (r && r.isReactWarning)
-          return !1;
-      }
-      return e.ref !== void 0;
+  };
+}
+const Ut = (t) => t.join(","), jt = (t) => t.join(",");
+function On(t, n, o) {
+  let r, { shape: e } = n, { computedStyle: a } = n, { transform: c } = n, { viewportScale: i = 1 } = n;
+  const l = (u, y, g) => {
+    let p;
+    const m = u.geometry;
+    y === "SHAPE" ? p = m.points.map(([S, O]) => [S + g[0], O + g[1]]) : p = m.points.map(([S, O], I) => y === `HANDLE-${I}` ? [S + g[0], O + g[1]] : [S, O]);
+    const w = gn(p);
+    return { ...u, geometry: { points: p, bounds: w } };
+  };
+  function h(u) {
+    R.call(this, t, u);
+  }
+  function d(u) {
+    R.call(this, t, u);
+  }
+  function $(u) {
+    R.call(this, t, u);
+  }
+  return t.$$set = (u) => {
+    "shape" in u && o(0, e = u.shape), "computedStyle" in u && o(1, a = u.computedStyle), "transform" in u && o(2, c = u.transform), "viewportScale" in u && o(3, i = u.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && o(4, r = e.geometry);
+  }, [
+    e,
+    a,
+    c,
+    i,
+    r,
+    l,
+    h,
+    d,
+    $
+  ];
+}
+class Sn extends yt {
+  constructor(n) {
+    super(), gt(this, n, On, En, dt, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 3
+    });
+  }
+}
+const Pn = "ontouchstart" in window || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
+function Ln(t) {
+  let n, o, r, e, a, c;
+  return {
+    c() {
+      n = M("rect"), s(n, "class", o = ht(`a9s-handle ${/*$$props*/
+      t[8].class || ""}`.trim()) + " svelte-1sgkh33"), s(n, "x", r = /*x*/
+      t[0] - /*handleSize*/
+      t[5] / 2), s(n, "y", e = /*y*/
+      t[1] - /*handleSize*/
+      t[5] / 2), s(
+        n,
+        "width",
+        /*handleSize*/
+        t[5]
+      ), s(
+        n,
+        "height",
+        /*handleSize*/
+        t[5]
+      );
+    },
+    m(i, l) {
+      E(i, n, l), a || (c = P(
+        n,
+        "pointerdown",
+        /*pointerdown_handler_2*/
+        t[11]
+      ), a = !0);
+    },
+    p(i, l) {
+      l & /*$$props*/
+      256 && o !== (o = ht(`a9s-handle ${/*$$props*/
+      i[8].class || ""}`.trim()) + " svelte-1sgkh33") && s(n, "class", o), l & /*x, handleSize*/
+      33 && r !== (r = /*x*/
+      i[0] - /*handleSize*/
+      i[5] / 2) && s(n, "x", r), l & /*y, handleSize*/
+      34 && e !== (e = /*y*/
+      i[1] - /*handleSize*/
+      i[5] / 2) && s(n, "y", e), l & /*handleSize*/
+      32 && s(
+        n,
+        "width",
+        /*handleSize*/
+        i[5]
+      ), l & /*handleSize*/
+      32 && s(
+        n,
+        "height",
+        /*handleSize*/
+        i[5]
+      );
+    },
+    d(i) {
+      i && b(n), a = !1, c();
     }
-    function Ue(e) {
-      if (S.call(e, "key")) {
-        var r = Object.getOwnPropertyDescriptor(e, "key").get;
-        if (r && r.isReactWarning)
-          return !1;
-      }
-      return e.key !== void 0;
+  };
+}
+function _n(t) {
+  let n, o, r, e, a, c, i, l, h;
+  return {
+    c() {
+      n = M("g"), o = M("circle"), e = M("rect"), s(
+        o,
+        "cx",
+        /*x*/
+        t[0]
+      ), s(
+        o,
+        "cy",
+        /*y*/
+        t[1]
+      ), s(o, "r", r = /*radius*/
+      t[3] / /*scale*/
+      t[2]), s(o, "class", "a9s-touch-halo svelte-1sgkh33"), kt(
+        o,
+        "touched",
+        /*touched*/
+        t[4]
+      ), s(e, "class", a = ht(`a9s-handle ${/*$$props*/
+      t[8].class || ""}`.trim()) + " svelte-1sgkh33"), s(e, "x", c = /*x*/
+      t[0] - /*handleSize*/
+      t[5] / 2), s(e, "y", i = /*y*/
+      t[1] - /*handleSize*/
+      t[5] / 2), s(
+        e,
+        "width",
+        /*handleSize*/
+        t[5]
+      ), s(
+        e,
+        "height",
+        /*handleSize*/
+        t[5]
+      ), s(n, "class", "a9s-touch-handle");
+    },
+    m(d, $) {
+      E(d, n, $), It(n, o), It(n, e), l || (h = [
+        P(
+          o,
+          "pointerdown",
+          /*pointerdown_handler*/
+          t[10]
+        ),
+        P(
+          o,
+          "pointerdown",
+          /*onPointerDown*/
+          t[6]
+        ),
+        P(
+          o,
+          "pointerup",
+          /*onPointerUp*/
+          t[7]
+        ),
+        P(
+          e,
+          "pointerdown",
+          /*pointerdown_handler_1*/
+          t[9]
+        ),
+        P(
+          e,
+          "pointerdown",
+          /*onPointerDown*/
+          t[6]
+        ),
+        P(
+          e,
+          "pointerup",
+          /*onPointerUp*/
+          t[7]
+        )
+      ], l = !0);
+    },
+    p(d, $) {
+      $ & /*x*/
+      1 && s(
+        o,
+        "cx",
+        /*x*/
+        d[0]
+      ), $ & /*y*/
+      2 && s(
+        o,
+        "cy",
+        /*y*/
+        d[1]
+      ), $ & /*radius, scale*/
+      12 && r !== (r = /*radius*/
+      d[3] / /*scale*/
+      d[2]) && s(o, "r", r), $ & /*touched*/
+      16 && kt(
+        o,
+        "touched",
+        /*touched*/
+        d[4]
+      ), $ & /*$$props*/
+      256 && a !== (a = ht(`a9s-handle ${/*$$props*/
+      d[8].class || ""}`.trim()) + " svelte-1sgkh33") && s(e, "class", a), $ & /*x, handleSize*/
+      33 && c !== (c = /*x*/
+      d[0] - /*handleSize*/
+      d[5] / 2) && s(e, "x", c), $ & /*y, handleSize*/
+      34 && i !== (i = /*y*/
+      d[1] - /*handleSize*/
+      d[5] / 2) && s(e, "y", i), $ & /*handleSize*/
+      32 && s(
+        e,
+        "width",
+        /*handleSize*/
+        d[5]
+      ), $ & /*handleSize*/
+      32 && s(
+        e,
+        "height",
+        /*handleSize*/
+        d[5]
+      );
+    },
+    d(d) {
+      d && b(n), l = !1, F(h);
     }
-    function Ne(e, r) {
-      if (typeof e.ref == "string" && m.current && r && m.current.stateNode !== r) {
-        var t = d(m.current.type);
-        Y[t] || (l('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', d(m.current.type), e.ref), Y[t] = !0);
-      }
+  };
+}
+function Mn(t) {
+  let n;
+  function o(e, a) {
+    return Pn ? _n : Ln;
+  }
+  let r = o()(t);
+  return {
+    c() {
+      r.c(), n = qt();
+    },
+    m(e, a) {
+      r.m(e, a), E(e, n, a);
+    },
+    p(e, [a]) {
+      r.p(e, a);
+    },
+    i: nt,
+    o: nt,
+    d(e) {
+      e && b(n), r.d(e);
     }
-    function Be(e, r) {
-      {
-        var t = function() {
-          se || (se = !0, l("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
-        };
-        t.isReactWarning = !0, Object.defineProperty(e, "key", {
-          get: t,
-          configurable: !0
-        });
-      }
+  };
+}
+function An(t, n, o) {
+  let r, { x: e } = n, { y: a } = n, { scale: c } = n, { radius: i = 30 } = n, l = !1;
+  const h = (g) => {
+    g.pointerType === "touch" && o(4, l = !0);
+  }, d = () => o(4, l = !1);
+  function $(g) {
+    R.call(this, t, g);
+  }
+  function u(g) {
+    R.call(this, t, g);
+  }
+  function y(g) {
+    R.call(this, t, g);
+  }
+  return t.$$set = (g) => {
+    o(8, n = Ot(Ot({}, n), Ht(g))), "x" in g && o(0, e = g.x), "y" in g && o(1, a = g.y), "scale" in g && o(2, c = g.scale), "radius" in g && o(3, i = g.radius);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*scale*/
+    4 && o(5, r = 10 / c);
+  }, n = Ht(n), [
+    e,
+    a,
+    c,
+    i,
+    l,
+    r,
+    h,
+    d,
+    n,
+    $,
+    u,
+    y
+  ];
+}
+class Y extends yt {
+  constructor(n) {
+    super(), gt(this, n, An, Mn, dt, { x: 0, y: 1, scale: 2, radius: 3 });
+  }
+}
+function Hn(t) {
+  let n, o, r, e, a, c, i, l, h, d, $, u, y, g, p, m, w, S, O, I, N, B, q, L, V, rt, et, mt, A, st, at, ct, $t, U, xt, j, wt, C, Tt, X, T, bt, _t;
+  return U = new Y({
+    props: {
+      class: "a9s-corner-handle-topleft",
+      x: (
+        /*geom*/
+        t[4].x
+      ),
+      y: (
+        /*geom*/
+        t[4].y
+      ),
+      scale: (
+        /*viewportScale*/
+        t[3]
+      )
     }
-    function qe(e, r) {
-      {
-        var t = function() {
-          fe || (fe = !0, l("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
-        };
-        t.isReactWarning = !0, Object.defineProperty(e, "ref", {
-          get: t,
-          configurable: !0
-        });
-      }
+  }), U.$on("pointerdown", function() {
+    _(
+      /*grab*/
+      t[9]("TOP_LEFT")
+    ) && t[9]("TOP_LEFT").apply(this, arguments);
+  }), j = new Y({
+    props: {
+      class: "a9s-corner-handle-topright",
+      x: (
+        /*geom*/
+        t[4].x + /*geom*/
+        t[4].w
+      ),
+      y: (
+        /*geom*/
+        t[4].y
+      ),
+      scale: (
+        /*viewportScale*/
+        t[3]
+      )
     }
-    var Ge = function(e, r, t, n, o, u, i) {
-      var a = {
-        // This tag allows us to uniquely identify this as a React Element
-        $$typeof: x,
-        // Built-in properties that belong on the element
-        type: e,
-        key: r,
-        ref: t,
-        props: i,
-        // Record the component responsible for creating this element.
-        _owner: u
-      };
-      return a._store = {}, Object.defineProperty(a._store, "validated", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !0,
-        value: !1
-      }), Object.defineProperty(a, "_self", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !1,
-        value: n
-      }), Object.defineProperty(a, "_source", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !1,
-        value: o
-      }), Object.freeze && (Object.freeze(a.props), Object.freeze(a)), a;
-    };
-    function ze(e, r, t, n, o) {
-      {
-        var u, i = {}, a = null, c = null;
-        t !== void 0 && (ue(t), a = "" + t), Ue(r) && (ue(r.key), a = "" + r.key), Le(r) && (c = r.ref, Ne(r, o));
-        for (u in r)
-          S.call(r, u) && !Ve.hasOwnProperty(u) && (i[u] = r[u]);
-        if (e && e.defaultProps) {
-          var s = e.defaultProps;
-          for (u in s)
-            i[u] === void 0 && (i[u] = s[u]);
-        }
-        if (a || c) {
-          var f = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
-          a && Be(i, f), c && qe(i, f);
-        }
-        return Ge(e, a, c, o, n, m.current, i);
-      }
+  }), j.$on("pointerdown", function() {
+    _(
+      /*grab*/
+      t[9]("TOP_RIGHT")
+    ) && t[9]("TOP_RIGHT").apply(this, arguments);
+  }), C = new Y({
+    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]
+      )
     }
-    var M = b.ReactCurrentOwner, le = b.ReactDebugCurrentFrame;
-    function h(e) {
-      if (e) {
-        var r = e._owner, t = O(e.type, e._source, r ? r.type : null);
-        le.setExtraStackFrame(t);
-      } else
-        le.setExtraStackFrame(null);
+  }), C.$on("pointerdown", function() {
+    _(
+      /*grab*/
+      t[9]("BOTTOM_RIGHT")
+    ) && t[9]("BOTTOM_RIGHT").apply(this, arguments);
+  }), X = new Y({
+    props: {
+      class: "a9s-corner-handle-bottomleft",
+      x: (
+        /*geom*/
+        t[4].x
+      ),
+      y: (
+        /*geom*/
+        t[4].y + /*geom*/
+        t[4].h
+      ),
+      scale: (
+        /*viewportScale*/
+        t[3]
+      )
     }
-    var V;
-    V = !1;
-    function L(e) {
-      return typeof e == "object" && e !== null && e.$$typeof === x;
+  }), X.$on("pointerdown", function() {
+    _(
+      /*grab*/
+      t[9]("BOTTOM_LEFT")
+    ) && t[9]("BOTTOM_LEFT").apply(this, arguments);
+  }), {
+    c() {
+      n = M("rect"), i = k(), l = M("rect"), y = k(), g = M("rect"), S = k(), O = M("rect"), q = k(), L = M("rect"), mt = k(), A = M("rect"), $t = k(), Q(U.$$.fragment), xt = k(), Q(j.$$.fragment), wt = k(), Q(C.$$.fragment), Tt = k(), Q(X.$$.fragment), s(n, "class", "a9s-outer"), s(n, "style", o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), s(n, "x", r = /*geom*/
+      t[4].x), s(n, "y", e = /*geom*/
+      t[4].y), s(n, "width", a = /*geom*/
+      t[4].w), s(n, "height", c = /*geom*/
+      t[4].h), s(l, "class", "a9s-inner a9s-shape-handle"), s(
+        l,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), s(l, "x", h = /*geom*/
+      t[4].x), s(l, "y", d = /*geom*/
+      t[4].y), s(l, "width", $ = /*geom*/
+      t[4].w), s(l, "height", u = /*geom*/
+      t[4].h), s(g, "class", "a9s-edge-handle a9s-edge-handle-top"), s(g, "x", p = /*geom*/
+      t[4].x), s(g, "y", m = /*geom*/
+      t[4].y), s(g, "height", 1), s(g, "width", w = /*geom*/
+      t[4].w), s(O, "class", "a9s-edge-handle a9s-edge-handle-right"), s(O, "x", I = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w), s(O, "y", N = /*geom*/
+      t[4].y), s(O, "height", B = /*geom*/
+      t[4].h), s(O, "width", 1), s(L, "class", "a9s-edge-handle a9s-edge-handle-bottom"), s(L, "x", V = /*geom*/
+      t[4].x), s(L, "y", rt = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h), s(L, "height", 1), s(L, "width", et = /*geom*/
+      t[4].w), s(A, "class", "a9s-edge-handle a9s-edge-handle-left"), s(A, "x", st = /*geom*/
+      t[4].x), s(A, "y", at = /*geom*/
+      t[4].y), s(A, "height", ct = /*geom*/
+      t[4].h), s(A, "width", 1);
+    },
+    m(x, f) {
+      E(x, n, f), E(x, i, f), E(x, l, f), E(x, y, f), E(x, g, f), E(x, S, f), E(x, O, f), E(x, q, f), E(x, L, f), E(x, mt, f), E(x, A, f), E(x, $t, f), D(U, x, f), E(x, xt, f), D(j, x, f), E(x, wt, f), D(C, x, f), E(x, Tt, f), D(X, x, f), T = !0, bt || (_t = [
+        P(n, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("SHAPE")
+          ) && t[9]("SHAPE").apply(this, arguments);
+        }),
+        P(l, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("SHAPE")
+          ) && t[9]("SHAPE").apply(this, arguments);
+        }),
+        P(g, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("TOP")
+          ) && t[9]("TOP").apply(this, arguments);
+        }),
+        P(O, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("RIGHT")
+          ) && t[9]("RIGHT").apply(this, arguments);
+        }),
+        P(L, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("BOTTOM")
+          ) && t[9]("BOTTOM").apply(this, arguments);
+        }),
+        P(A, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[9]("LEFT")
+          ) && t[9]("LEFT").apply(this, arguments);
+        })
+      ], bt = !0);
+    },
+    p(x, f) {
+      t = x, (!T || f & /*computedStyle*/
+      2 && o !== (o = /*computedStyle*/
+      t[1] ? "display:none;" : void 0)) && s(n, "style", o), (!T || f & /*geom*/
+      16 && r !== (r = /*geom*/
+      t[4].x)) && s(n, "x", r), (!T || f & /*geom*/
+      16 && e !== (e = /*geom*/
+      t[4].y)) && s(n, "y", e), (!T || f & /*geom*/
+      16 && a !== (a = /*geom*/
+      t[4].w)) && s(n, "width", a), (!T || f & /*geom*/
+      16 && c !== (c = /*geom*/
+      t[4].h)) && s(n, "height", c), (!T || f & /*computedStyle*/
+      2) && s(
+        l,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), (!T || f & /*geom*/
+      16 && h !== (h = /*geom*/
+      t[4].x)) && s(l, "x", h), (!T || f & /*geom*/
+      16 && d !== (d = /*geom*/
+      t[4].y)) && s(l, "y", d), (!T || f & /*geom*/
+      16 && $ !== ($ = /*geom*/
+      t[4].w)) && s(l, "width", $), (!T || f & /*geom*/
+      16 && u !== (u = /*geom*/
+      t[4].h)) && s(l, "height", u), (!T || f & /*geom*/
+      16 && p !== (p = /*geom*/
+      t[4].x)) && s(g, "x", p), (!T || f & /*geom*/
+      16 && m !== (m = /*geom*/
+      t[4].y)) && s(g, "y", m), (!T || f & /*geom*/
+      16 && w !== (w = /*geom*/
+      t[4].w)) && s(g, "width", w), (!T || f & /*geom*/
+      16 && I !== (I = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w)) && s(O, "x", I), (!T || f & /*geom*/
+      16 && N !== (N = /*geom*/
+      t[4].y)) && s(O, "y", N), (!T || f & /*geom*/
+      16 && B !== (B = /*geom*/
+      t[4].h)) && s(O, "height", B), (!T || f & /*geom*/
+      16 && V !== (V = /*geom*/
+      t[4].x)) && s(L, "x", V), (!T || f & /*geom*/
+      16 && rt !== (rt = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h)) && s(L, "y", rt), (!T || f & /*geom*/
+      16 && et !== (et = /*geom*/
+      t[4].w)) && s(L, "width", et), (!T || f & /*geom*/
+      16 && st !== (st = /*geom*/
+      t[4].x)) && s(A, "x", st), (!T || f & /*geom*/
+      16 && at !== (at = /*geom*/
+      t[4].y)) && s(A, "y", at), (!T || f & /*geom*/
+      16 && ct !== (ct = /*geom*/
+      t[4].h)) && s(A, "height", ct);
+      const it = {};
+      f & /*geom*/
+      16 && (it.x = /*geom*/
+      t[4].x), f & /*geom*/
+      16 && (it.y = /*geom*/
+      t[4].y), f & /*viewportScale*/
+      8 && (it.scale = /*viewportScale*/
+      t[3]), U.$set(it);
+      const lt = {};
+      f & /*geom*/
+      16 && (lt.x = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w), f & /*geom*/
+      16 && (lt.y = /*geom*/
+      t[4].y), f & /*viewportScale*/
+      8 && (lt.scale = /*viewportScale*/
+      t[3]), j.$set(lt);
+      const ut = {};
+      f & /*geom*/
+      16 && (ut.x = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w), f & /*geom*/
+      16 && (ut.y = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h), f & /*viewportScale*/
+      8 && (ut.scale = /*viewportScale*/
+      t[3]), C.$set(ut);
+      const pt = {};
+      f & /*geom*/
+      16 && (pt.x = /*geom*/
+      t[4].x), f & /*geom*/
+      16 && (pt.y = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h), f & /*viewportScale*/
+      8 && (pt.scale = /*viewportScale*/
+      t[3]), X.$set(pt);
+    },
+    i(x) {
+      T || (H(U.$$.fragment, x), H(j.$$.fragment, x), H(C.$$.fragment, x), H(X.$$.fragment, x), T = !0);
+    },
+    o(x) {
+      G(U.$$.fragment, x), G(j.$$.fragment, x), G(C.$$.fragment, x), G(X.$$.fragment, x), T = !1;
+    },
+    d(x) {
+      x && (b(n), b(i), b(l), b(y), b(g), b(S), b(O), b(q), b(L), b(mt), b(A), b($t), b(xt), b(wt), b(Tt)), z(U, x), z(j, x), z(C, x), z(X, x), bt = !1, F(_t);
     }
-    function ce() {
-      {
-        if (M.current) {
-          var e = d(M.current.type);
-          if (e)
-            return `
-
-Check the render method of \`` + e + "`.";
-        }
-        return "";
-      }
+  };
+}
+function In(t) {
+  let n, o;
+  return n = new Kt({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          Hn,
+          ({ grab: r }) => ({ 9: r }),
+          ({ grab: r }) => r ? 512 : 0
+        ]
+      },
+      $$scope: { ctx: t }
     }
-    function Je(e) {
-      {
-        if (e !== void 0) {
-          var r = e.fileName.replace(/^.*[\\\/]/, ""), t = e.lineNumber;
-          return `
-
-Check your code at ` + r + ":" + t + ".";
-        }
-        return "";
-      }
+  }), n.$on(
+    "grab",
+    /*grab_handler*/
+    t[6]
+  ), n.$on(
+    "change",
+    /*change_handler*/
+    t[7]
+  ), n.$on(
+    "release",
+    /*release_handler*/
+    t[8]
+  ), {
+    c() {
+      Q(n.$$.fragment);
+    },
+    m(r, e) {
+      D(n, r, e), o = !0;
+    },
+    p(r, [e]) {
+      const a = {};
+      e & /*shape*/
+      1 && (a.shape = /*shape*/
+      r[0]), e & /*transform*/
+      4 && (a.transform = /*transform*/
+      r[2]), e & /*$$scope, geom, viewportScale, grab, computedStyle*/
+      1562 && (a.$$scope = { dirty: e, ctx: r }), n.$set(a);
+    },
+    i(r) {
+      o || (H(n.$$.fragment, r), o = !0);
+    },
+    o(r) {
+      G(n.$$.fragment, r), o = !1;
+    },
+    d(r) {
+      z(n, r);
     }
-    var ve = {};
-    function Ke(e) {
-      {
-        var r = ce();
-        if (!r) {
-          var t = typeof e == "string" ? e : e.displayName || e.name;
-          t && (r = `
-
-Check the top-level render call using <` + t + ">.");
+  };
+}
+function kn(t, n, o) {
+  let r, { shape: e } = n, { computedStyle: a } = n, { transform: c } = n, { viewportScale: i = 1 } = n;
+  const l = (u, y, g) => {
+    const p = u.geometry.bounds;
+    let [m, w] = [p.minX, p.minY], [S, O] = [p.maxX, p.maxY];
+    const [I, N] = g;
+    if (y === "SHAPE")
+      m += I, S += I, w += N, O += N;
+    else {
+      switch (y) {
+        case "TOP":
+        case "TOP_LEFT":
+        case "TOP_RIGHT": {
+          w += N;
+          break;
         }
-        return r;
-      }
-    }
-    function de(e, r) {
-      {
-        if (!e._store || e._store.validated || e.key != null)
-          return;
-        e._store.validated = !0;
-        var t = Ke(r);
-        if (ve[t])
-          return;
-        ve[t] = !0;
-        var n = "";
-        e && e._owner && e._owner !== M.current && (n = " It was passed a child from " + d(e._owner.type) + "."), h(e), l('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', t, n), h(null);
-      }
-    }
-    function pe(e, r) {
-      {
-        if (typeof e != "object")
-          return;
-        if ($(e))
-          for (var t = 0; t < e.length; t++) {
-            var n = e[t];
-            L(n) && de(n, r);
-          }
-        else if (L(e))
-          e._store && (e._store.validated = !0);
-        else if (e) {
-          var o = _e(e);
-          if (typeof o == "function" && o !== e.entries)
-            for (var u = o.call(e), i; !(i = u.next()).done; )
-              L(i.value) && de(i.value, r);
+        case "BOTTOM":
+        case "BOTTOM_LEFT":
+        case "BOTTOM_RIGHT": {
+          O += N;
+          break;
         }
       }
-    }
-    function He(e) {
-      {
-        var r = e.type;
-        if (r == null || typeof r == "string")
-          return;
-        var t;
-        if (typeof r == "function")
-          t = r.propTypes;
-        else if (typeof r == "object" && (r.$$typeof === T || // Note: Memo only checks outer props here.
-        // Inner props are checked in the reconciler.
-        r.$$typeof === C))
-          t = r.propTypes;
-        else
-          return;
-        if (t) {
-          var n = d(r);
-          We(t, e.props, "prop", n, e);
-        } else if (r.PropTypes !== void 0 && !V) {
-          V = !0;
-          var o = d(r);
-          l("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", o || "Unknown");
+      switch (y) {
+        case "LEFT":
+        case "TOP_LEFT":
+        case "BOTTOM_LEFT": {
+          m += I;
+          break;
         }
-        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && l("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
-      }
-    }
-    function Xe(e) {
-      {
-        for (var r = Object.keys(e.props), t = 0; t < r.length; t++) {
-          var n = r[t];
-          if (n !== "children" && n !== "key") {
-            h(e), l("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", n), h(null);
-            break;
-          }
+        case "RIGHT":
+        case "TOP_RIGHT":
+        case "BOTTOM_RIGHT": {
+          S += I;
+          break;
         }
-        e.ref !== null && (h(e), l("Invalid attribute `ref` supplied to `React.Fragment`."), h(null));
       }
     }
-    function ge(e, r, t, n, o, u) {
-      {
-        var i = je(e);
-        if (!i) {
-          var a = "";
-          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (a += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
-          var c = Je(o);
-          c ? a += c : a += ce();
-          var s;
-          e === null ? s = "null" : $(e) ? s = "array" : e !== void 0 && e.$$typeof === x ? (s = "<" + (d(e.type) || "Unknown") + " />", a = " Did you accidentally export a JSX literal instead of a component?") : s = typeof e, l("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", s, a);
+    const B = Math.min(m, S), q = Math.min(w, O), L = Math.abs(S - m), V = Math.abs(O - w);
+    return {
+      ...u,
+      geometry: {
+        x: B,
+        y: q,
+        w: L,
+        h: V,
+        bounds: {
+          minX: B,
+          minY: q,
+          maxX: B + L,
+          maxY: q + V
         }
-        var f = ze(e, r, t, o, u);
-        if (f == null)
-          return f;
-        if (i) {
-          var v = r.children;
-          if (v !== void 0)
-            if (n)
-              if ($(v)) {
-                for (var E = 0; E < v.length; E++)
-                  pe(v[E], e);
-                Object.freeze && Object.freeze(v);
-              } else
-                l("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
-            else
-              pe(v, e);
-        }
-        return e === _ ? Xe(f) : He(f), f;
       }
+    };
+  };
+  function h(u) {
+    R.call(this, t, u);
+  }
+  function d(u) {
+    R.call(this, t, u);
+  }
+  function $(u) {
+    R.call(this, t, u);
+  }
+  return t.$$set = (u) => {
+    "shape" in u && o(0, e = u.shape), "computedStyle" in u && o(1, a = u.computedStyle), "transform" in u && o(2, c = u.transform), "viewportScale" in u && o(3, i = u.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && o(4, r = e.geometry);
+  }, [
+    e,
+    a,
+    c,
+    i,
+    r,
+    l,
+    h,
+    d,
+    $
+  ];
+}
+class Gn extends yt {
+  constructor(n) {
+    super(), gt(this, n, kn, In, dt, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 3
+    });
+  }
+}
+v.RECTANGLE, v.POLYGON;
+const Nn = (t) => ({}), Ct = (t) => ({ grab: (
+  /*onGrab*/
+  t[0]
+) });
+function Rn(t) {
+  let n, o, r, e;
+  const a = (
+    /*#slots*/
+    t[7].default
+  ), c = Zt(
+    a,
+    t,
+    /*$$scope*/
+    t[6],
+    Ct
+  );
+  return {
+    c() {
+      n = M("g"), c && c.c(), s(n, "class", "a9s-annotation selected");
+    },
+    m(i, l) {
+      E(i, n, l), c && c.m(n, null), o = !0, r || (e = [
+        P(
+          n,
+          "pointerup",
+          /*onRelease*/
+          t[2]
+        ),
+        P(
+          n,
+          "pointermove",
+          /*onPointerMove*/
+          t[1]
+        )
+      ], r = !0);
+    },
+    p(i, [l]) {
+      c && c.p && (!o || l & /*$$scope*/
+      64) && Yt(
+        c,
+        a,
+        i,
+        /*$$scope*/
+        i[6],
+        o ? vt(
+          a,
+          /*$$scope*/
+          i[6],
+          l,
+          Nn
+        ) : tn(
+          /*$$scope*/
+          i[6]
+        ),
+        Ct
+      );
+    },
+    i(i) {
+      o || (H(c, i), o = !0);
+    },
+    o(i) {
+      G(c, i), o = !1;
+    },
+    d(i) {
+      i && b(n), c && c.d(i), r = !1, F(e);
     }
-    function Ze(e, r, t) {
-      return ge(e, r, t, !0);
-    }
-    function Qe(e, r, t) {
-      return ge(e, r, t, !1);
+  };
+}
+function Fn(t, n, o) {
+  let { $$slots: r = {}, $$scope: e } = n;
+  const a = sn();
+  let { shape: c } = n, { editor: i } = n, { transform: l } = n, h, d, $;
+  const u = (p) => (m) => {
+    h = p, d = l.elementToImage(m.offsetX, m.offsetY), $ = c, m.target.setPointerCapture(m.pointerId), a("grab", m);
+  }, y = (p) => {
+    if (h) {
+      const [m, w] = l.elementToImage(p.offsetX, p.offsetY), S = [m - d[0], w - d[1]];
+      o(3, c = i($, h, S)), a("change", c);
     }
-    var er = Qe, rr = Ze;
-    R.Fragment = _, R.jsx = er, R.jsxs = rr;
-  }(), R);
+  }, g = (p) => {
+    p.target.releasePointerCapture(p.pointerId), h = void 0, $ = c, a("release", p);
+  };
+  return t.$$set = (p) => {
+    "shape" in p && o(3, c = p.shape), "editor" in p && o(4, i = p.editor), "transform" in p && o(5, l = p.transform), "$$scope" in p && o(6, e = p.$$scope);
+  }, [u, y, g, c, i, l, e, r];
+}
+class Kt extends yt {
+  constructor(n) {
+    super(), gt(this, n, Fn, Rn, dt, { shape: 3, editor: 4, transform: 5 });
+  }
 }
+navigator.userAgent.indexOf("Mac OS X");
 export {
-  ir as __require
+  Kt as Editor,
+  Y as Handle,
+  Sn as PolygonEditor,
+  Gn as RectangleEditor,
+  $n as RectangleUtil,
+  v as ShapeType,
+  gn as boundsFromPoints,
+  Pn as isTouch,
+  Lt as registerShapeUtil
 };
 //# sourceMappingURL=annotorious-react-manifold.es9.js.map