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

package/dist/annotorious-svelte.es5.js

@@ -1,117 +1,1294 @@
-import { safe_not_equal as g, create_slot as b, update_slot_base as h, get_all_dirty_from_scope as k, get_slot_changes as w } from "./annotorious-svelte.es7.js";
-import { empty as A, insert as O, detach as v } from "./annotorious-svelte.es8.js";
-import { transition_in as f, transition_out as c, check_outros as C, group_outros as q } from "./annotorious-svelte.es9.js";
-import { setContext as _ } from "./annotorious-svelte.es10.js";
-import { SvelteComponent as y, init as D } from "./annotorious-svelte.es11.js";
-import "./annotorious-svelte.es12.js";
-import { toSvelteStore as E } from "./annotorious-svelte.es3.js";
-import { createOSDAnnotator as I } from "./annotorious-svelte.es14.js";
-function d(s) {
-  let o;
-  const n = (
-    /*#slots*/
-    s[4].default
-  ), t = b(
-    n,
-    s,
-    /*$$scope*/
-    s[3],
-    null
-  );
+function xt() {
+}
+function qt(t, n) {
+  for (const r in n)
+    t[r] = n[r];
+  return t;
+}
+function Yt(t) {
+  return t();
+}
+function Mt() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function z(t) {
+  t.forEach(Yt);
+}
+function _(t) {
+  return typeof t == "function";
+}
+function Et(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 Qt(t, n, r, o) {
+  if (t) {
+    const s = jt(t, n, r, o);
+    return t[0](s);
+  }
+}
+function jt(t, n, r, o) {
+  return t[1] && o ? qt(r.ctx.slice(), t[1](o(n))) : r.ctx;
+}
+function Zt(t, n, r, o) {
+  if (t[2] && o) {
+    const s = t[2](o(r));
+    if (n.dirty === void 0)
+      return s;
+    if (typeof s == "object") {
+      const a = [], c = Math.max(n.dirty.length, s.length);
+      for (let l = 0; l < c; l += 1)
+        a[l] = n.dirty[l] | s[l];
+      return a;
+    }
+    return n.dirty | s;
+  }
+  return n.dirty;
+}
+function Kt(t, n, r, o, s, a) {
+  if (s) {
+    const c = jt(n, r, o, a);
+    t.p(c, s);
+  }
+}
+function Rt(t) {
+  if (t.ctx.length > 32) {
+    const n = [], r = t.ctx.length / 32;
+    for (let o = 0; o < r; o++)
+      n[o] = -1;
+    return n;
+  }
+  return -1;
+}
+function T(t, n, r) {
+  t.insertBefore(n, r || null);
+}
+function x(t) {
+  t.parentNode && t.parentNode.removeChild(t);
+}
+function tn(t, n) {
+  for (let r = 0; r < t.length; r += 1)
+    t[r] && t[r].d(n);
+}
+function L(t) {
+  return document.createElementNS("http://www.w3.org/2000/svg", t);
+}
+function Ot(t) {
+  return document.createTextNode(t);
+}
+function U() {
+  return Ot(" ");
+}
+function nn() {
+  return Ot("");
+}
+function A(t, n, r, o) {
+  return t.addEventListener(n, r, o), () => t.removeEventListener(n, r, o);
+}
+function e(t, n, r) {
+  r == null ? t.removeAttribute(n) : t.getAttribute(n) !== r && t.setAttribute(n, r);
+}
+function rn(t) {
+  return Array.from(t.childNodes);
+}
+function on(t, n, { bubbles: r = !1, cancelable: o = !1 } = {}) {
+  const s = document.createEvent("CustomEvent");
+  return s.initCustomEvent(t, r, o, n), s;
+}
+let Q;
+function J(t) {
+  Q = t;
+}
+function en() {
+  if (!Q)
+    throw new Error("Function called outside component initialization");
+  return Q;
+}
+function sn() {
+  const t = en();
+  return (n, r, { cancelable: o = !1 } = {}) => {
+    const s = t.$$.callbacks[n];
+    if (s) {
+      const a = on(n, r, { cancelable: o });
+      return s.slice().forEach((c) => {
+        c.call(t, a);
+      }), !a.defaultPrevented;
+    }
+    return !0;
+  };
+}
+function V(t, n) {
+  const r = t.$$.callbacks[n.type];
+  r && r.slice().forEach((o) => o.call(this, n));
+}
+const W = [], It = [];
+let q = [];
+const Ft = [], an = /* @__PURE__ */ Promise.resolve();
+let wt = !1;
+function cn() {
+  wt || (wt = !0, an.then(Xt));
+}
+function Tt(t) {
+  q.push(t);
+}
+const $t = /* @__PURE__ */ new Set();
+let D = 0;
+function Xt() {
+  if (D !== 0)
+    return;
+  const t = Q;
+  do {
+    try {
+      for (; D < W.length; ) {
+        const n = W[D];
+        D++, J(n), ln(n.$$);
+      }
+    } catch (n) {
+      throw W.length = 0, D = 0, n;
+    }
+    for (J(null), W.length = 0, D = 0; It.length; )
+      It.pop()();
+    for (let n = 0; n < q.length; n += 1) {
+      const r = q[n];
+      $t.has(r) || ($t.add(r), r());
+    }
+    q.length = 0;
+  } while (W.length);
+  for (; Ft.length; )
+    Ft.pop()();
+  wt = !1, $t.clear(), J(t);
+}
+function ln(t) {
+  if (t.fragment !== null) {
+    t.update(), z(t.before_update);
+    const n = t.dirty;
+    t.dirty = [-1], t.fragment && t.fragment.p(t.ctx, n), t.after_update.forEach(Tt);
+  }
+}
+function pn(t) {
+  const n = [], r = [];
+  q.forEach((o) => t.indexOf(o) === -1 ? n.push(o) : r.push(o)), r.forEach((o) => o()), q = n;
+}
+const pt = /* @__PURE__ */ new Set();
+let un;
+function ut(t, n) {
+  t && t.i && (pt.delete(t), t.i(n));
+}
+function bt(t, n, r, o) {
+  if (t && t.o) {
+    if (pt.has(t))
+      return;
+    pt.add(t), un.c.push(() => {
+      pt.delete(t), o && (r && t.d(1), o());
+    }), t.o(n);
+  } else
+    o && o();
+}
+function zt(t) {
+  t && t.c();
+}
+function St(t, n, r, o) {
+  const { fragment: s, after_update: a } = t.$$;
+  s && s.m(n, r), o || Tt(() => {
+    const c = t.$$.on_mount.map(Yt).filter(_);
+    t.$$.on_destroy ? t.$$.on_destroy.push(...c) : z(c), t.$$.on_mount = [];
+  }), a.forEach(Tt);
+}
+function vt(t, n) {
+  const r = t.$$;
+  r.fragment !== null && (pn(r.after_update), z(r.on_destroy), r.fragment && r.fragment.d(n), r.on_destroy = r.fragment = null, r.ctx = []);
+}
+function hn(t, n) {
+  t.$$.dirty[0] === -1 && (W.push(t), cn(), t.$$.dirty.fill(0)), t.$$.dirty[n / 31 | 0] |= 1 << n % 31;
+}
+function Pt(t, n, r, o, s, a, c, l = [-1]) {
+  const p = Q;
+  J(t);
+  const f = t.$$ = {
+    fragment: null,
+    ctx: [],
+    // state
+    props: a,
+    update: xt,
+    not_equal: s,
+    bound: Mt(),
+    // lifecycle
+    on_mount: [],
+    on_destroy: [],
+    on_disconnect: [],
+    before_update: [],
+    after_update: [],
+    context: new Map(n.context || (p ? p.$$.context : [])),
+    // everything else
+    callbacks: Mt(),
+    dirty: l,
+    skip_bound: !1,
+    root: n.target || p.$$.root
+  };
+  c && c(f.root);
+  let w = !1;
+  if (f.ctx = r ? r(t, n.props || {}, ($, m, ...i) => {
+    const y = i.length ? i[0] : m;
+    return f.ctx && s(f.ctx[$], f.ctx[$] = y) && (!f.skip_bound && f.bound[$] && f.bound[$](y), w && hn(t, $)), m;
+  }) : [], f.update(), w = !0, z(f.before_update), f.fragment = o ? o(f.ctx) : !1, n.target) {
+    if (n.hydrate) {
+      const $ = rn(n.target);
+      f.fragment && f.fragment.l($), $.forEach(x);
+    } else
+      f.fragment && f.fragment.c();
+    n.intro && ut(t.$$.fragment), St(t, n.target, n.anchor, n.customElement), Xt();
+  }
+  J(p);
+}
+class _t {
+  $destroy() {
+    vt(this, 1), this.$destroy = xt;
+  }
+  $on(n, r) {
+    if (!_(r))
+      return xt;
+    const o = this.$$.callbacks[n] || (this.$$.callbacks[n] = []);
+    return o.push(r), () => {
+      const s = o.indexOf(r);
+      s !== -1 && o.splice(s, 1);
+    };
+  }
+  $set(n) {
+    this.$$set && !Jt(n) && (this.$$.skip_bound = !0, this.$$set(n), this.$$.skip_bound = !1);
+  }
+}
+var B = /* @__PURE__ */ ((t) => (t.ELLIPSE = "ELLIPSE", t.POLYGON = "POLYGON", t.RECTANGLE = "RECTANGLE", t))(B || {});
+const At = (t, n) => n, Dt = (t) => {
+  let n = 1 / 0, r = 1 / 0, o = -1 / 0, s = -1 / 0;
+  return t.forEach(([a, c]) => {
+    n = Math.min(n, a), r = Math.min(r, c), o = Math.max(o, a), s = Math.max(s, c);
+  }), { minX: n, minY: r, maxX: o, maxY: s };
+}, dn = {
+  area: (t) => Math.PI * t.geometry.rx * t.geometry.ry,
+  intersects: (t, n, r) => {
+    const { cx: o, cy: s, rx: a, ry: c } = t.geometry, l = 0, p = Math.cos(l), f = Math.sin(l), w = n - o, $ = r - s, m = p * w + f * $, i = f * w - p * $;
+    return m * m / (a * a) + i * i / (c * c) <= 1;
+  }
+};
+At(B.ELLIPSE, dn);
+const fn = {
+  area: (t) => {
+    const { points: n } = t.geometry;
+    let r = 0, o = n.length - 1;
+    for (let s = 0; s < n.length; s++)
+      r += (n[o][0] + n[s][0]) * (n[o][1] - n[s][1]), o = s;
+    return Math.abs(0.5 * r);
+  },
+  intersects: (t, n, r) => {
+    const { points: o } = t.geometry;
+    let s = !1;
+    for (let a = 0, c = o.length - 1; a < o.length; c = a++) {
+      const l = o[a][0], p = o[a][1], f = o[c][0], w = o[c][1];
+      p > r != w > r && n < (f - l) * (r - p) / (w - p) + l && (s = !s);
+    }
+    return s;
+  }
+};
+At(B.POLYGON, fn);
+const yn = {
+  area: (t) => t.geometry.w * t.geometry.h,
+  intersects: (t, n, r) => n >= t.geometry.x && n <= t.geometry.x + t.geometry.w && r >= t.geometry.y && r <= t.geometry.y + t.geometry.h
+};
+At(B.RECTANGLE, yn);
+const gn = (t, n = !1) => {
+  const r = typeof t == "string" ? t : t.value, o = /^(xywh)=(pixel|percent)?:?(.+?),(.+?),(.+?),(.+)*/g, s = [...r.matchAll(o)][0], [a, c, l, p, f, w, $] = s;
+  if (c !== "xywh")
+    throw new Error("Unsupported MediaFragment: " + r);
+  if (l && l !== "pixel")
+    throw new Error(`Unsupported MediaFragment unit: ${l}`);
+  const [m, i, y, h] = [p, f, w, $].map(parseFloat);
+  return {
+    type: B.RECTANGLE,
+    geometry: {
+      x: m,
+      y: i,
+      w: y,
+      h,
+      bounds: {
+        minX: m,
+        minY: n ? i - h : i,
+        maxX: m + y,
+        maxY: n ? i : i + h
+      }
+    }
+  };
+}, mn = (t) => {
+  const { x: n, y: r, w: o, h: s } = t;
+  return {
+    type: "FragmentSelector",
+    conformsTo: "http://www.w3.org/TR/media-frags/",
+    value: `xywh=pixel:${n},${r},${o},${s}`
+  };
+}, Wt = "http://www.w3.org/2000/svg", Ht = (t) => {
+  const n = (o) => {
+    Array.from(o.attributes).forEach((s) => {
+      s.name.startsWith("on") && o.removeAttribute(s.name);
+    });
+  }, r = t.getElementsByTagName("script");
+  return Array.from(r).reverse().forEach((o) => o.parentNode.removeChild(o)), Array.from(t.querySelectorAll("*")).forEach(n), t;
+}, $n = (t) => {
+  const n = new XMLSerializer().serializeToString(t.documentElement).replace("<svg>", `<svg xmlns="${Wt}">`);
+  return new DOMParser().parseFromString(n, "image/svg+xml").documentElement;
+}, xn = (t) => {
+  const n = new DOMParser().parseFromString(t, "image/svg+xml"), r = n.lookupPrefix(Wt), o = n.lookupNamespaceURI(null);
+  return r || o ? Ht(n).firstChild : Ht($n(n)).firstChild;
+}, wn = (t) => {
+  const [n, r, o] = t.match(/(<polygon points=["|'])([^("|')]*)/) || [];
+  if (!o)
+    return;
+  const s = o.split(" ").map((a) => a.split(",").map(parseFloat));
+  return {
+    type: B.POLYGON,
+    geometry: {
+      points: s,
+      bounds: Dt(s)
+    }
+  };
+}, Tn = (t) => {
+  const n = xn(t), r = parseFloat(n.getAttribute("cx")), o = parseFloat(n.getAttribute("cy")), s = parseFloat(n.getAttribute("rx")), a = parseFloat(n.getAttribute("ry")), c = {
+    minX: r - s,
+    minY: o - a,
+    maxX: r + s,
+    maxY: o + a
+  };
+  return {
+    type: B.ELLIPSE,
+    geometry: {
+      cx: r,
+      cy: o,
+      rx: s,
+      ry: a,
+      bounds: c
+    }
+  };
+}, En = (t) => {
+  const n = typeof t == "string" ? t : t.value;
+  if (n.includes("<polygon points="))
+    return wn(n);
+  if (n.includes("<ellipse "))
+    return Tn(n);
+}, bn = (t) => {
+  let n;
+  if (t.type === B.POLYGON) {
+    const r = t.geometry, { points: o } = r;
+    n = `<svg><polygon points="${o.map((s) => s.join(",")).join(" ")}" /></svg>`;
+  } else if (t.type === B.ELLIPSE) {
+    const r = t.geometry;
+    n = `<svg><ellipse cx="${r.cx}" cy="${r.cy}" rx="${r.rx}" ry="${r.ry}" /></svg>`;
+  }
+  if (n)
+    return { type: "SvgSelector", value: n };
+  throw `Unsupported shape type: ${t.type}`;
+};
+let lt;
+const Sn = new Uint8Array(16);
+function vn() {
+  if (!lt && (lt = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !lt))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return lt(Sn);
+}
+const S = [];
+for (let t = 0; t < 256; ++t)
+  S.push((t + 256).toString(16).slice(1));
+function Pn(t, n = 0) {
+  return S[t[n + 0]] + S[t[n + 1]] + S[t[n + 2]] + S[t[n + 3]] + "-" + S[t[n + 4]] + S[t[n + 5]] + "-" + S[t[n + 6]] + S[t[n + 7]] + "-" + S[t[n + 8]] + S[t[n + 9]] + "-" + S[t[n + 10]] + S[t[n + 11]] + S[t[n + 12]] + S[t[n + 13]] + S[t[n + 14]] + S[t[n + 15]];
+}
+const _n = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), Gt = {
+  randomUUID: _n
+};
+function An(t, n, r) {
+  if (Gt.randomUUID && !n && !t)
+    return Gt.randomUUID();
+  t = t || {};
+  const o = t.random || (t.rng || vn)();
+  if (o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, n) {
+    r = r || 0;
+    for (let s = 0; s < 16; ++s)
+      n[r + s] = o[s];
+    return n;
+  }
+  return Pn(o);
+}
+let Ln = (t = 21) => crypto.getRandomValues(new Uint8Array(t)).reduce((n, r) => (r &= 63, r < 36 ? n += r.toString(36) : r < 62 ? n += (r - 26).toString(36).toUpperCase() : r > 62 ? n += "-" : n += "_", n), "");
+const Mn = (t) => {
+  const n = JSON.stringify(t);
+  let r = 0;
+  for (let o = 0, s = n.length; o < s; o++) {
+    let a = n.charCodeAt(o);
+    r = (r << 5) - r + a, r |= 0;
+  }
+  return `${r}`;
+}, In = (t, n) => (Array.isArray(t) ? t : [t]).map((r) => {
+  const { id: o, type: s, purpose: a, value: c, created: l, creator: p, ...f } = r;
+  return {
+    id: o || `temp-${Mn(r)}`,
+    annotation: n,
+    type: s,
+    purpose: a,
+    value: c,
+    created: l,
+    creator: p ? typeof p == "object" ? { ...p } : p : void 0,
+    ...f
+  };
+}), Fn = (t) => t.map((n) => {
+  var r;
+  const o = { ...n };
+  return delete o.annotation, (r = o.id) != null && r.startsWith("temp-") && delete o.id, o;
+});
+Ln();
+const Wn = (t, n = !1) => ({ parse: (r) => Hn(r, n), serialize: (r) => Gn(r, t) }), Hn = (t, n = !1) => {
+  const r = t.id || An(), { body: o, ...s } = t, a = In(o, r), c = Array.isArray(t.target) ? t.target[0] : t.target, l = Array.isArray(c.selector) ? c.selector[0] : c.selector, p = l.type === "FragmentSelector" ? gn(l, n) : l.type === "SvgSelector" ? En(l) : void 0;
+  return p ? {
+    parsed: {
+      ...s,
+      id: r,
+      bodies: a,
+      target: {
+        annotation: r,
+        selector: p
+      }
+    }
+  } : {
+    error: Error(`Unknown selector type: ${l.type}`)
+  };
+}, Gn = (t, n) => {
+  const r = t.target.selector, o = r.type == B.RECTANGLE ? mn(r.geometry) : bn(r);
+  return {
+    ...t,
+    "@context": "http://www.w3.org/ns/anno.jsonld",
+    id: t.id,
+    type: "Annotation",
+    body: Fn(t.bodies),
+    target: {
+      source: n,
+      selector: o
+    }
+  };
+};
+function Nt(t, n, r) {
+  const o = t.slice();
+  return o[11] = n[r], o[13] = r, o;
+}
+function Bt(t) {
+  let n, r, o, s, a;
   return {
     c() {
-      t && t.c();
+      n = L("rect"), e(n, "class", "a9s-corner-handle"), e(n, "x", r = /*point*/
+      t[11][0] - /*handleSize*/
+      t[3] / 2), e(n, "y", o = /*point*/
+      t[11][1] - /*handleSize*/
+      t[3] / 2), e(
+        n,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), e(
+        n,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
     },
-    m(e, r) {
-      t && t.m(e, r), o = !0;
+    m(c, l) {
+      T(c, n, l), s || (a = A(n, "pointerdown", function() {
+        _(
+          /*grab*/
+          t[10](d(
+            /*idx*/
+            t[13]
+          ))
+        ) && t[10](d(
+          /*idx*/
+          t[13]
+        )).apply(this, arguments);
+      }), s = !0);
     },
-    p(e, r) {
-      t && t.p && (!o || r & /*$$scope*/
-      8) && h(
-        t,
+    p(c, l) {
+      t = c, l & /*geom, handleSize*/
+      24 && r !== (r = /*point*/
+      t[11][0] - /*handleSize*/
+      t[3] / 2) && e(n, "x", r), l & /*geom, handleSize*/
+      24 && o !== (o = /*point*/
+      t[11][1] - /*handleSize*/
+      t[3] / 2) && e(n, "y", o), l & /*handleSize*/
+      8 && e(
         n,
-        e,
-        /*$$scope*/
-        e[3],
-        o ? w(
-          n,
-          /*$$scope*/
-          e[3],
-          r,
-          null
-        ) : k(
-          /*$$scope*/
-          e[3]
-        ),
-        null
+        "height",
+        /*handleSize*/
+        t[3]
+      ), l & /*handleSize*/
+      8 && e(
+        n,
+        "width",
+        /*handleSize*/
+        t[3]
       );
     },
-    i(e) {
-      o || (f(t, e), o = !0);
+    d(c) {
+      c && x(n), s = !1, a();
+    }
+  };
+}
+function Nn(t) {
+  let n, r, o, s, a, c, l, p, f, w, $ = (
+    /*geom*/
+    t[4].points
+  ), m = [];
+  for (let i = 0; i < $.length; i += 1)
+    m[i] = Bt(Nt(t, $, i));
+  return {
+    c() {
+      n = L("polygon"), s = U(), a = L("polygon"), l = U();
+      for (let i = 0; i < m.length; i += 1)
+        m[i].c();
+      p = nn(), e(n, "class", "a9s-outer"), e(n, "style", r = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), e(n, "points", o = /*geom*/
+      t[4].points.map(Ct).join(" ")), e(a, "class", "a9s-inner a9s-shape-handle"), e(
+        a,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), e(a, "points", c = /*geom*/
+      t[4].points.map(Ut).join(" "));
+    },
+    m(i, y) {
+      T(i, n, y), T(i, s, y), T(i, a, y), T(i, l, y);
+      for (let h = 0; h < m.length; h += 1)
+        m[h] && m[h].m(i, y);
+      T(i, p, y), f || (w = [
+        A(n, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.SHAPE)
+          ) && t[10](d.SHAPE).apply(this, arguments);
+        }),
+        A(a, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.SHAPE)
+          ) && t[10](d.SHAPE).apply(this, arguments);
+        })
+      ], f = !0);
     },
-    o(e) {
-      c(t, e), o = !1;
+    p(i, y) {
+      if (t = i, y & /*computedStyle*/
+      2 && r !== (r = /*computedStyle*/
+      t[1] ? "display:none;" : void 0) && e(n, "style", r), y & /*geom*/
+      16 && o !== (o = /*geom*/
+      t[4].points.map(Ct).join(" ")) && e(n, "points", o), y & /*computedStyle*/
+      2 && e(
+        a,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), y & /*geom*/
+      16 && c !== (c = /*geom*/
+      t[4].points.map(Ut).join(" ")) && e(a, "points", c), y & /*geom, handleSize, grab, Handle*/
+      1048) {
+        $ = /*geom*/
+        t[4].points;
+        let h;
+        for (h = 0; h < $.length; h += 1) {
+          const E = Nt(t, $, h);
+          m[h] ? m[h].p(E, y) : (m[h] = Bt(E), m[h].c(), m[h].m(p.parentNode, p));
+        }
+        for (; h < m.length; h += 1)
+          m[h].d(1);
+        m.length = $.length;
+      }
     },
-    d(e) {
-      t && t.d(e);
+    d(i) {
+      i && x(n), i && x(s), i && x(a), i && x(l), tn(m, i), i && x(p), f = !1, z(w);
     }
   };
 }
-function L(s) {
-  let o, n, t = (
-    /*viewer*/
-    s[0] && d(s)
+function Bn(t) {
+  let n, r;
+  return n = new Vt({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          Nn,
+          ({ grab: o }) => ({ 10: o }),
+          ({ grab: o }) => o ? 1024 : 0
+        ]
+      },
+      $$scope: { ctx: t }
+    }
+  }), n.$on(
+    "change",
+    /*change_handler*/
+    t[7]
+  ), n.$on(
+    "grab",
+    /*grab_handler*/
+    t[8]
+  ), n.$on(
+    "release",
+    /*release_handler*/
+    t[9]
+  ), {
+    c() {
+      zt(n.$$.fragment);
+    },
+    m(o, s) {
+      St(n, o, s), r = !0;
+    },
+    p(o, [s]) {
+      const a = {};
+      s & /*shape*/
+      1 && (a.shape = /*shape*/
+      o[0]), s & /*transform*/
+      4 && (a.transform = /*transform*/
+      o[2]), s & /*$$scope, geom, handleSize, grab, computedStyle*/
+      17434 && (a.$$scope = { dirty: s, ctx: o }), n.$set(a);
+    },
+    i(o) {
+      r || (ut(n.$$.fragment, o), r = !0);
+    },
+    o(o) {
+      bt(n.$$.fragment, o), r = !1;
+    },
+    d(o) {
+      vt(n, o);
+    }
+  };
+}
+const Ct = (t) => t.join(","), Ut = (t) => t.join(",");
+function Cn(t, n, r) {
+  let o, s, { shape: a } = n, { computedStyle: c = void 0 } = n, { transform: l } = n, { viewportScale: p = 1 } = n;
+  const f = (i, y, h) => {
+    let E;
+    y === d.SHAPE ? E = i.geometry.points.map(([P, b]) => [P + h[0], b + h[1]]) : E = i.geometry.points.map(([P, b], C) => y === d(C) ? [P + h[0], b + h[1]] : [P, b]);
+    const M = Dt(E);
+    return { ...i, geometry: { points: E, bounds: M } };
+  };
+  function w(i) {
+    V.call(this, t, i);
+  }
+  function $(i) {
+    V.call(this, t, i);
+  }
+  function m(i) {
+    V.call(this, t, i);
+  }
+  return t.$$set = (i) => {
+    "shape" in i && r(0, a = i.shape), "computedStyle" in i && r(1, c = i.computedStyle), "transform" in i && r(2, l = i.transform), "viewportScale" in i && r(6, p = i.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && r(4, o = a.geometry), t.$$.dirty & /*viewportScale*/
+    64 && r(3, s = 10 / p);
+  }, [
+    a,
+    c,
+    l,
+    s,
+    o,
+    f,
+    p,
+    w,
+    $,
+    m
+  ];
+}
+class Un extends _t {
+  constructor(n) {
+    super(), Pt(this, n, Cn, Bn, Et, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 6
+    });
+  }
+}
+function kn(t) {
+  let n, r, o, s, a, c, l, p, f, w, $, m, i, y, h, E, M, P, b, C, k, Y, j, v, O, X, Z, ht, N, K, R, tt, dt, I, nt, rt, ft, F, ot, et, yt, H, st, at, gt, G, it, ct, mt, Lt;
+  return {
+    c() {
+      n = L("rect"), l = U(), p = L("rect"), i = U(), y = L("rect"), P = U(), b = L("rect"), j = U(), v = L("rect"), ht = U(), N = L("rect"), dt = U(), I = L("rect"), ft = U(), F = L("rect"), yt = U(), H = L("rect"), gt = U(), G = L("rect"), e(n, "class", "a9s-outer"), e(n, "style", r = /*computedStyle*/
+      t[1] ? "display:none;" : void 0), e(n, "x", o = /*geom*/
+      t[4].x), e(n, "y", s = /*geom*/
+      t[4].y), e(n, "width", a = /*geom*/
+      t[4].w), e(n, "height", c = /*geom*/
+      t[4].h), e(p, "class", "a9s-inner a9s-shape-handle"), e(
+        p,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), e(p, "x", f = /*geom*/
+      t[4].x), e(p, "y", w = /*geom*/
+      t[4].y), e(p, "width", $ = /*geom*/
+      t[4].w), e(p, "height", m = /*geom*/
+      t[4].h), e(y, "class", "a9s-edge-handle a9s-edge-handle-top"), e(y, "x", h = /*geom*/
+      t[4].x), e(y, "y", E = /*geom*/
+      t[4].y), e(y, "height", 1), e(y, "width", M = /*geom*/
+      t[4].w), e(b, "class", "a9s-edge-handle a9s-edge-handle-right"), e(b, "x", C = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w), e(b, "y", k = /*geom*/
+      t[4].y), e(b, "height", Y = /*geom*/
+      t[4].h), e(b, "width", 1), e(v, "class", "a9s-edge-handle a9s-edge-handle-bottom"), e(v, "x", O = /*geom*/
+      t[4].x), e(v, "y", X = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h), e(v, "height", 1), e(v, "width", Z = /*geom*/
+      t[4].w), e(N, "class", "a9s-edge-handle a9s-edge-handle-left"), e(N, "x", K = /*geom*/
+      t[4].x), e(N, "y", R = /*geom*/
+      t[4].y), e(N, "height", tt = /*geom*/
+      t[4].h), e(N, "width", 1), e(I, "class", "a9s-corner-handle a9s-corner-handle-topleft"), e(I, "x", nt = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2), e(I, "y", rt = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2), e(
+        I,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), e(
+        I,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), e(F, "class", "a9s-corner-handle a9s-corner-handle-topright"), e(F, "x", ot = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2), e(F, "y", et = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2), e(
+        F,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), e(
+        F,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), e(H, "class", "a9s-corner-handle a9s-corner-handle-bottomright"), e(H, "x", st = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2), e(H, "y", at = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2), e(
+        H,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), e(
+        H,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), e(G, "class", "a9s-corner-handle a9s-corner-handle-bottomleft"), e(G, "x", it = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2), e(G, "y", ct = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2), e(
+        G,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), e(
+        G,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    m(g, u) {
+      T(g, n, u), T(g, l, u), T(g, p, u), T(g, i, u), T(g, y, u), T(g, P, u), T(g, b, u), T(g, j, u), T(g, v, u), T(g, ht, u), T(g, N, u), T(g, dt, u), T(g, I, u), T(g, ft, u), T(g, F, u), T(g, yt, u), T(g, H, u), T(g, gt, u), T(g, G, u), mt || (Lt = [
+        A(n, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.SHAPE)
+          ) && t[10](d.SHAPE).apply(this, arguments);
+        }),
+        A(p, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.SHAPE)
+          ) && t[10](d.SHAPE).apply(this, arguments);
+        }),
+        A(y, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.TOP)
+          ) && t[10](d.TOP).apply(this, arguments);
+        }),
+        A(b, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.RIGHT)
+          ) && t[10](d.RIGHT).apply(this, arguments);
+        }),
+        A(v, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.BOTTOM)
+          ) && t[10](d.BOTTOM).apply(this, arguments);
+        }),
+        A(N, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.LEFT)
+          ) && t[10](d.LEFT).apply(this, arguments);
+        }),
+        A(I, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.TOP_LEFT)
+          ) && t[10](d.TOP_LEFT).apply(this, arguments);
+        }),
+        A(F, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.TOP_RIGHT)
+          ) && t[10](d.TOP_RIGHT).apply(this, arguments);
+        }),
+        A(H, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.BOTTOM_RIGHT)
+          ) && t[10](d.BOTTOM_RIGHT).apply(this, arguments);
+        }),
+        A(G, "pointerdown", function() {
+          _(
+            /*grab*/
+            t[10](d.BOTTOM_LEFT)
+          ) && t[10](d.BOTTOM_LEFT).apply(this, arguments);
+        })
+      ], mt = !0);
+    },
+    p(g, u) {
+      t = g, u & /*computedStyle*/
+      2 && r !== (r = /*computedStyle*/
+      t[1] ? "display:none;" : void 0) && e(n, "style", r), u & /*geom*/
+      16 && o !== (o = /*geom*/
+      t[4].x) && e(n, "x", o), u & /*geom*/
+      16 && s !== (s = /*geom*/
+      t[4].y) && e(n, "y", s), u & /*geom*/
+      16 && a !== (a = /*geom*/
+      t[4].w) && e(n, "width", a), u & /*geom*/
+      16 && c !== (c = /*geom*/
+      t[4].h) && e(n, "height", c), u & /*computedStyle*/
+      2 && e(
+        p,
+        "style",
+        /*computedStyle*/
+        t[1]
+      ), u & /*geom*/
+      16 && f !== (f = /*geom*/
+      t[4].x) && e(p, "x", f), u & /*geom*/
+      16 && w !== (w = /*geom*/
+      t[4].y) && e(p, "y", w), u & /*geom*/
+      16 && $ !== ($ = /*geom*/
+      t[4].w) && e(p, "width", $), u & /*geom*/
+      16 && m !== (m = /*geom*/
+      t[4].h) && e(p, "height", m), u & /*geom*/
+      16 && h !== (h = /*geom*/
+      t[4].x) && e(y, "x", h), u & /*geom*/
+      16 && E !== (E = /*geom*/
+      t[4].y) && e(y, "y", E), u & /*geom*/
+      16 && M !== (M = /*geom*/
+      t[4].w) && e(y, "width", M), u & /*geom*/
+      16 && C !== (C = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w) && e(b, "x", C), u & /*geom*/
+      16 && k !== (k = /*geom*/
+      t[4].y) && e(b, "y", k), u & /*geom*/
+      16 && Y !== (Y = /*geom*/
+      t[4].h) && e(b, "height", Y), u & /*geom*/
+      16 && O !== (O = /*geom*/
+      t[4].x) && e(v, "x", O), u & /*geom*/
+      16 && X !== (X = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h) && e(v, "y", X), u & /*geom*/
+      16 && Z !== (Z = /*geom*/
+      t[4].w) && e(v, "width", Z), u & /*geom*/
+      16 && K !== (K = /*geom*/
+      t[4].x) && e(N, "x", K), u & /*geom*/
+      16 && R !== (R = /*geom*/
+      t[4].y) && e(N, "y", R), u & /*geom*/
+      16 && tt !== (tt = /*geom*/
+      t[4].h) && e(N, "height", tt), u & /*geom, handleSize*/
+      24 && nt !== (nt = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2) && e(I, "x", nt), u & /*geom, handleSize*/
+      24 && rt !== (rt = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2) && e(I, "y", rt), u & /*handleSize*/
+      8 && e(
+        I,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u & /*handleSize*/
+      8 && e(
+        I,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u & /*geom, handleSize*/
+      24 && ot !== (ot = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2) && e(F, "x", ot), u & /*geom, handleSize*/
+      24 && et !== (et = /*geom*/
+      t[4].y - /*handleSize*/
+      t[3] / 2) && e(F, "y", et), u & /*handleSize*/
+      8 && e(
+        F,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u & /*handleSize*/
+      8 && e(
+        F,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u & /*geom, handleSize*/
+      24 && st !== (st = /*geom*/
+      t[4].x + /*geom*/
+      t[4].w - /*handleSize*/
+      t[3] / 2) && e(H, "x", st), u & /*geom, handleSize*/
+      24 && at !== (at = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2) && e(H, "y", at), u & /*handleSize*/
+      8 && e(
+        H,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u & /*handleSize*/
+      8 && e(
+        H,
+        "width",
+        /*handleSize*/
+        t[3]
+      ), u & /*geom, handleSize*/
+      24 && it !== (it = /*geom*/
+      t[4].x - /*handleSize*/
+      t[3] / 2) && e(G, "x", it), u & /*geom, handleSize*/
+      24 && ct !== (ct = /*geom*/
+      t[4].y + /*geom*/
+      t[4].h - /*handleSize*/
+      t[3] / 2) && e(G, "y", ct), u & /*handleSize*/
+      8 && e(
+        G,
+        "height",
+        /*handleSize*/
+        t[3]
+      ), u & /*handleSize*/
+      8 && e(
+        G,
+        "width",
+        /*handleSize*/
+        t[3]
+      );
+    },
+    d(g) {
+      g && x(n), g && x(l), g && x(p), g && x(i), g && x(y), g && x(P), g && x(b), g && x(j), g && x(v), g && x(ht), g && x(N), g && x(dt), g && x(I), g && x(ft), g && x(F), g && x(yt), g && x(H), g && x(gt), g && x(G), mt = !1, z(Lt);
+    }
+  };
+}
+function Yn(t) {
+  let n, r;
+  return n = new Vt({
+    props: {
+      shape: (
+        /*shape*/
+        t[0]
+      ),
+      transform: (
+        /*transform*/
+        t[2]
+      ),
+      editor: (
+        /*editor*/
+        t[5]
+      ),
+      $$slots: {
+        default: [
+          kn,
+          ({ grab: o }) => ({ 10: o }),
+          ({ grab: o }) => o ? 1024 : 0
+        ]
+      },
+      $$scope: { ctx: t }
+    }
+  }), n.$on(
+    "grab",
+    /*grab_handler*/
+    t[7]
+  ), n.$on(
+    "change",
+    /*change_handler*/
+    t[8]
+  ), n.$on(
+    "release",
+    /*release_handler*/
+    t[9]
+  ), {
+    c() {
+      zt(n.$$.fragment);
+    },
+    m(o, s) {
+      St(n, o, s), r = !0;
+    },
+    p(o, [s]) {
+      const a = {};
+      s & /*shape*/
+      1 && (a.shape = /*shape*/
+      o[0]), s & /*transform*/
+      4 && (a.transform = /*transform*/
+      o[2]), s & /*$$scope, geom, handleSize, grab, computedStyle*/
+      3098 && (a.$$scope = { dirty: s, ctx: o }), n.$set(a);
+    },
+    i(o) {
+      r || (ut(n.$$.fragment, o), r = !0);
+    },
+    o(o) {
+      bt(n.$$.fragment, o), r = !1;
+    },
+    d(o) {
+      vt(n, o);
+    }
+  };
+}
+function jn(t, n, r) {
+  let o, s, { shape: a } = n, { computedStyle: c = void 0 } = n, { transform: l } = n, { viewportScale: p = 1 } = n;
+  const f = (i, y, h) => {
+    const E = i.geometry.bounds;
+    let [M, P] = [E.minX, E.minY], [b, C] = [E.maxX, E.maxY];
+    const [k, Y] = h;
+    if (y === d.SHAPE)
+      M += k, b += k, P += Y, C += Y;
+    else {
+      switch (y) {
+        case d.TOP:
+        case d.TOP_LEFT:
+        case d.TOP_RIGHT: {
+          P += Y;
+          break;
+        }
+        case d.BOTTOM:
+        case d.BOTTOM_LEFT:
+        case d.BOTTOM_RIGHT: {
+          C += Y;
+          break;
+        }
+      }
+      switch (y) {
+        case d.LEFT:
+        case d.TOP_LEFT:
+        case d.BOTTOM_LEFT: {
+          M += k;
+          break;
+        }
+        case d.RIGHT:
+        case d.TOP_RIGHT:
+        case d.BOTTOM_RIGHT: {
+          b += k;
+          break;
+        }
+      }
+    }
+    const j = Math.min(M, b), v = Math.min(P, C), O = Math.abs(b - M), X = Math.abs(C - P);
+    return {
+      ...i,
+      geometry: {
+        x: j,
+        y: v,
+        w: O,
+        h: X,
+        bounds: {
+          minX: j,
+          minY: v,
+          maxX: j + O,
+          maxY: v + X
+        }
+      }
+    };
+  };
+  function w(i) {
+    V.call(this, t, i);
+  }
+  function $(i) {
+    V.call(this, t, i);
+  }
+  function m(i) {
+    V.call(this, t, i);
+  }
+  return t.$$set = (i) => {
+    "shape" in i && r(0, a = i.shape), "computedStyle" in i && r(1, c = i.computedStyle), "transform" in i && r(2, l = i.transform), "viewportScale" in i && r(6, p = i.viewportScale);
+  }, t.$$.update = () => {
+    t.$$.dirty & /*shape*/
+    1 && r(4, o = a.geometry), t.$$.dirty & /*viewportScale*/
+    64 && r(3, s = 10 / p);
+  }, [
+    a,
+    c,
+    l,
+    s,
+    o,
+    f,
+    p,
+    w,
+    $,
+    m
+  ];
+}
+class On extends _t {
+  constructor(n) {
+    super(), Pt(this, n, jn, Yn, Et, {
+      shape: 0,
+      computedStyle: 1,
+      transform: 2,
+      viewportScale: 6
+    });
+  }
+}
+B.RECTANGLE, B.POLYGON;
+const d = (t) => `HANDLE-${t}`;
+d.SHAPE = "SHAPE";
+d.TOP = "TOP";
+d.RIGHT = "RIGHT";
+d.BOTTOM = "BOTTOM";
+d.LEFT = "LEFT";
+d.TOP_LEFT = "TOP_LEFT";
+d.TOP_RIGHT = "TOP_RIGHT";
+d.BOTTOM_RIGHT = "BOTTOM_RIGHT";
+d.BOTTOM_LEFT = "BOTTOM_LEFT";
+const Xn = (t) => ({}), kt = (t) => ({ grab: (
+  /*onGrab*/
+  t[0]
+) });
+function zn(t) {
+  let n, r, o, s;
+  const a = (
+    /*#slots*/
+    t[7].default
+  ), c = Qt(
+    a,
+    t,
+    /*$$scope*/
+    t[6],
+    kt
   );
   return {
     c() {
-      t && t.c(), o = A();
+      n = L("g"), c && c.c(), e(n, "class", "a9s-annotation selected");
     },
-    m(e, r) {
-      t && t.m(e, r), O(e, o, r), n = !0;
+    m(l, p) {
+      T(l, n, p), c && c.m(n, null), r = !0, o || (s = [
+        A(
+          n,
+          "pointerup",
+          /*onRelease*/
+          t[2]
+        ),
+        A(
+          n,
+          "pointermove",
+          /*onPointerMove*/
+          t[1]
+        )
+      ], o = !0);
     },
-    p(e, [r]) {
-      /*viewer*/
-      e[0] ? t ? (t.p(e, r), r & /*viewer*/
-      1 && f(t, 1)) : (t = d(e), t.c(), f(t, 1), t.m(o.parentNode, o)) : t && (q(), c(t, 1, 1, () => {
-        t = null;
-      }), C());
+    p(l, [p]) {
+      c && c.p && (!r || p & /*$$scope*/
+      64) && Kt(
+        c,
+        a,
+        l,
+        /*$$scope*/
+        l[6],
+        r ? Zt(
+          a,
+          /*$$scope*/
+          l[6],
+          p,
+          Xn
+        ) : Rt(
+          /*$$scope*/
+          l[6]
+        ),
+        kt
+      );
     },
-    i(e) {
-      n || (f(t), n = !0);
+    i(l) {
+      r || (ut(c, l), r = !0);
     },
-    o(e) {
-      c(t), n = !1;
+    o(l) {
+      bt(c, l), r = !1;
     },
-    d(e) {
-      e && v(o), t && t.d(e);
+    d(l) {
+      l && x(n), c && c.d(l), o = !1, z(s);
     }
   };
 }
-function N(s, o, n) {
-  let { $$slots: t = {}, $$scope: e } = o, { viewer: r } = o, { opts: l = {} } = o, { anno: a = void 0 } = o;
-  const p = (i) => {
-    if (i) {
-      const u = I(i, l), S = E(u.state.store), m = {
-        ...u,
-        state: { ...u.state, store: S }
-      };
-      _("anno", m), _("viewer", i), n(1, a = m);
+function Dn(t, n, r) {
+  let { $$slots: o = {}, $$scope: s } = n;
+  const a = sn();
+  let { shape: c } = n, { editor: l } = n, { transform: p } = n, f = null, w, $ = null;
+  const m = (h) => (E) => {
+    f = h, w = p.elementToImage(E.offsetX, E.offsetY), $ = c, E.target.setPointerCapture(E.pointerId), a("grab");
+  }, i = (h) => {
+    if (f) {
+      const [E, M] = p.elementToImage(h.offsetX, h.offsetY), P = [E - w[0], M - w[1]];
+      r(3, c = l($, f, P)), a("change", c);
     }
+  }, y = (h) => {
+    h.target.releasePointerCapture(h.pointerId), f = null, $ = c, a("release");
   };
-  return s.$$set = (i) => {
-    "viewer" in i && n(0, r = i.viewer), "opts" in i && n(2, l = i.opts), "anno" in i && n(1, a = i.anno), "$$scope" in i && n(3, e = i.$$scope);
-  }, s.$$.update = () => {
-    s.$$.dirty & /*viewer*/
-    1 && p(r);
-  }, [r, a, l, e, t];
+  return t.$$set = (h) => {
+    "shape" in h && r(3, c = h.shape), "editor" in h && r(4, l = h.editor), "transform" in h && r(5, p = h.transform), "$$scope" in h && r(6, s = h.$$scope);
+  }, [m, i, y, c, l, p, s, o];
 }
-class j extends y {
-  constructor(o) {
-    super(), D(this, o, N, L, g, { viewer: 0, opts: 2, anno: 1 });
+class Vt extends _t {
+  constructor(n) {
+    super(), Pt(this, n, Dn, zn, Et, { shape: 3, editor: 4, transform: 5 });
   }
 }
-const P = j;
+navigator.userAgent.indexOf("Mac OS X");
 export {
-  P as default
+  Vt as Editor,
+  d as Handle,
+  Un as PolygonEditor,
+  On as RectangleEditor,
+  yn as RectangleUtil,
+  B as ShapeType,
+  Wn as W3CImageFormat,
+  Dt as boundsFromPoints,
+  gn as parseFragmentSelector,
+  En as parseSVGSelector,
+  In as parseW3CBodies,
+  Hn as parseW3CImageAnnotation,
+  At as registerShapeUtil,
+  mn as serializeFragmentSelector,
+  bn as serializeSVGSelector,
+  Fn as serializeW3CBodies,
+  Gn as serializeW3CImageAnnotation
 };
 //# sourceMappingURL=annotorious-svelte.es5.js.map