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

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

@@ -1,33 +1,1389 @@
-import { __exports as t } from "./annotorious-react-manifold.es11.js";
-import R from "react";
-/**
- * @license React
- * react-jsx-runtime.production.min.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 p;
-function v() {
-  if (p)
-    return t;
-  p = 1;
-  var s = R, m = Symbol.for("react.element"), l = Symbol.for("react.fragment"), c = Object.prototype.hasOwnProperty, d = s.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, y = { key: !0, ref: !0, __self: !0, __source: !0 };
-  function i(o, r, u) {
-    var e, n = {}, _ = null, f = null;
-    u !== void 0 && (_ = "" + u), r.key !== void 0 && (_ = "" + r.key), r.ref !== void 0 && (f = r.ref);
-    for (e in r)
-      c.call(r, e) && !y.hasOwnProperty(e) && (n[e] = r[e]);
-    if (o && o.defaultProps)
-      for (e in r = o.defaultProps, r)
-        n[e] === void 0 && (n[e] = r[e]);
-    return { $$typeof: m, type: o, key: _, ref: f, props: n, _owner: d.current };
-  }
-  return t.Fragment = l, t.jsx = i, t.jsxs = i, t;
+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;
+    }
+    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;
+    }
+    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;
+    }
+    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());
+    }
+    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);
+    }
+    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]
+      )
+    }
+  }), 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 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));
+        }
+        for (pn(), w = u.length; w < y.length; w += 1)
+          g(w);
+        fn();
+      }
+    },
+    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 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 }
+    }
+  }), 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);
+    }
+  };
+}
+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 _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 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 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]
+      )
+    }
+  }), 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]
+      )
+    }
+  }), 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]
+      )
+    }
+  }), 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]
+      )
+    }
+  }), 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 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 }
+    }
+  }), 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);
+    }
+  };
+}
+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;
+        }
+        case "BOTTOM":
+        case "BOTTOM_LEFT":
+        case "BOTTOM_RIGHT": {
+          O += N;
+          break;
+        }
+      }
+      switch (y) {
+        case "LEFT":
+        case "TOP_LEFT":
+        case "BOTTOM_LEFT": {
+          m += I;
+          break;
+        }
+        case "RIGHT":
+        case "TOP_RIGHT":
+        case "BOTTOM_RIGHT": {
+          S += I;
+          break;
+        }
+      }
+    }
+    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
+        }
+      }
+    };
+  };
+  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 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);
+    }
+  }, 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 {
-  v 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