@annotorious/core 3.0.0-rc.2 → 3.0.0-rc.20

package/dist/annotorious-core.es.js

@@ -0,0 +1,776 @@
+var _ = Object.prototype.hasOwnProperty;
+function x(e, n) {
+  var t, o;
+  if (e === n)
+    return !0;
+  if (e && n && (t = e.constructor) === n.constructor) {
+    if (t === Date)
+      return e.getTime() === n.getTime();
+    if (t === RegExp)
+      return e.toString() === n.toString();
+    if (t === Array) {
+      if ((o = e.length) === n.length)
+        for (; o-- && x(e[o], n[o]); )
+          ;
+      return o === -1;
+    }
+    if (!t || typeof e == "object") {
+      o = 0;
+      for (t in e)
+        if (_.call(e, t) && ++o && !_.call(n, t) || !(t in n) || !x(e[t], n[t]))
+          return !1;
+      return Object.keys(n).length === o;
+    }
+  }
+  return e !== e && n !== n;
+}
+function z() {
+}
+function W(e, n) {
+  return e != e ? n == n : e !== n || e && typeof e == "object" || typeof e == "function";
+}
+const k = [];
+function Y(e, n = z) {
+  let t;
+  const o = /* @__PURE__ */ new Set();
+  function i(E) {
+    if (W(e, E) && (e = E, t)) {
+      const w = !k.length;
+      for (const u of o)
+        u[1](), k.push(u, e);
+      if (w) {
+        for (let u = 0; u < k.length; u += 2)
+          k[u][0](k[u + 1]);
+        k.length = 0;
+      }
+    }
+  }
+  function p(E) {
+    i(E(e));
+  }
+  function U(E, w = z) {
+    const u = [E, w];
+    return o.add(u), o.size === 1 && (t = n(i, p) || z), E(e), () => {
+      o.delete(u), o.size === 0 && t && (t(), t = null);
+    };
+  }
+  return { set: i, update: p, subscribe: U };
+}
+const ve = (e) => {
+  const { subscribe: n, set: t } = Y();
+  let o;
+  return n((i) => o = i), e.observe(({ changes: i }) => {
+    if (o) {
+      (i.deleted || []).some((E) => E.id === o) && t(void 0);
+      const U = (i.updated || []).find(({ oldValue: E }) => E.id === o);
+      U && t(U.newValue.id);
+    }
+  }), {
+    get current() {
+      return o;
+    },
+    subscribe: n,
+    set: t
+  };
+};
+var q = /* @__PURE__ */ ((e) => (e.EDIT = "EDIT", e.SELECT = "SELECT", e.NONE = "NONE", e))(q || {});
+const V = { selected: [] }, ye = (e, n = "EDIT") => {
+  const { subscribe: t, set: o } = Y(V);
+  let i = V;
+  t((s) => i = s);
+  const p = () => o(V), U = () => {
+    var s;
+    return ((s = i.selected) == null ? void 0 : s.length) === 0;
+  }, E = (s) => {
+    if (i.selected.length === 0)
+      return !1;
+    const h = typeof s == "string" ? s : s.id;
+    return i.selected.some((C) => C.id === h);
+  }, w = (s, h) => {
+    const C = e.getAnnotation(s);
+    if (C) {
+      const b = G(C, n);
+      o(b === "EDIT" ? { selected: [{ id: s, editable: !0 }], pointerEvent: h } : b === "SELECT" ? { selected: [{ id: s }], pointerEvent: h } : { selected: [], pointerEvent: h });
+    } else
+      console.warn("Invalid selection: " + s);
+  }, u = (s, h = !0) => {
+    const C = Array.isArray(s) ? s : [s], b = C.map((S) => e.getAnnotation(S)).filter(Boolean);
+    o({ selected: b.map(({ id: S }) => ({ id: S, editable: h })) }), b.length !== C.length && console.warn("Invalid selection", s);
+  }, L = (s) => {
+    if (i.selected.length === 0)
+      return !1;
+    const { selected: h } = i;
+    h.filter(({ id: b }) => s.includes(b)).length > 0 && o({ selected: h.filter(({ id: b }) => !s.includes(b)) });
+  };
+  return e.observe(({ changes: s }) => L((s.deleted || []).map((h) => h.id))), {
+    clear: p,
+    clickSelect: w,
+    get selected() {
+      return i ? [...i.selected] : null;
+    },
+    get pointerEvent() {
+      return i ? i.pointerEvent : null;
+    },
+    isEmpty: U,
+    isSelected: E,
+    setSelected: u,
+    subscribe: t
+  };
+}, G = (e, n) => typeof n == "function" ? n(e) || "EDIT" : n || "EDIT";
+let $;
+const H = new Uint8Array(16);
+function F() {
+  if (!$ && ($ = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !$))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return $(H);
+}
+const D = [];
+for (let e = 0; e < 256; ++e)
+  D.push((e + 256).toString(16).slice(1));
+function J(e, n = 0) {
+  return D[e[n + 0]] + D[e[n + 1]] + D[e[n + 2]] + D[e[n + 3]] + "-" + D[e[n + 4]] + D[e[n + 5]] + "-" + D[e[n + 6]] + D[e[n + 7]] + "-" + D[e[n + 8]] + D[e[n + 9]] + "-" + D[e[n + 10]] + D[e[n + 11]] + D[e[n + 12]] + D[e[n + 13]] + D[e[n + 14]] + D[e[n + 15]];
+}
+const Q = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), j = {
+  randomUUID: Q
+};
+function X(e, n, t) {
+  if (j.randomUUID && !n && !e)
+    return j.randomUUID();
+  e = e || {};
+  const o = e.random || (e.rng || F)();
+  if (o[6] = o[6] & 15 | 64, o[8] = o[8] & 63 | 128, n) {
+    t = t || 0;
+    for (let i = 0; i < 16; ++i)
+      n[t + i] = o[i];
+    return n;
+  }
+  return J(o);
+}
+const we = (e) => {
+  const { creator: n, updatedBy: t } = e.target, o = e.bodies.reduce((i, p) => [...i, p.creator, p.updatedBy].filter(Boolean), []);
+  return [
+    n,
+    t,
+    ...o
+  ].filter((i) => i);
+}, Ce = (e, n, t, o) => ({
+  id: X(),
+  annotation: e.id,
+  created: t || /* @__PURE__ */ new Date(),
+  creator: o,
+  ...n
+}), Z = (e, n) => {
+  const t = new Set(e.bodies.map((o) => o.id));
+  return n.bodies.filter((o) => !t.has(o.id));
+}, K = (e, n) => {
+  const t = new Set(n.bodies.map((o) => o.id));
+  return e.bodies.filter((o) => !t.has(o.id));
+}, ee = (e, n) => n.bodies.map((t) => {
+  const o = e.bodies.find((i) => i.id === t.id);
+  return { newBody: t, oldBody: o && !x(o, t) ? o : void 0 };
+}).filter(({ oldBody: t }) => t).map(({ oldBody: t, newBody: o }) => ({ oldBody: t, newBody: o })), te = (e, n) => !x(e.target, n.target), M = (e, n) => {
+  const t = Z(e, n), o = K(e, n), i = ee(e, n);
+  return {
+    oldValue: e,
+    newValue: n,
+    bodiesCreated: t.length > 0 ? t : void 0,
+    bodiesDeleted: o.length > 0 ? o : void 0,
+    bodiesUpdated: i.length > 0 ? i : void 0,
+    targetUpdated: te(e, n) ? { oldTarget: e.target, newTarget: n.target } : void 0
+  };
+};
+var ne = /* @__PURE__ */ ((e) => (e.BODY_ONLY = "BODY_ONLY", e.TARGET_ONLY = "TARGET_ONLY", e))(ne || {}), O = /* @__PURE__ */ ((e) => (e.LOCAL = "LOCAL", e.REMOTE = "REMOTE", e))(O || {});
+const oe = (e, n) => {
+  var p, U;
+  const { changes: t, origin: o } = n;
+  if (!(!e.options.origin || e.options.origin === o))
+    return !1;
+  if (e.options.ignore) {
+    const { ignore: E } = e.options, w = (L) => L && L.length > 0;
+    if (!(w(t.created) || w(t.deleted))) {
+      const L = (p = t.updated) == null ? void 0 : p.some((h) => w(h.bodiesCreated) || w(h.bodiesDeleted) || w(h.bodiesUpdated)), s = (U = t.updated) == null ? void 0 : U.some((h) => h.targetUpdated);
+      if (E === "BODY_ONLY" && L && !s || E === "TARGET_ONLY" && s && !L)
+        return !1;
+    }
+  }
+  if (e.options.annotations) {
+    const E = /* @__PURE__ */ new Set([
+      ...(t.created || []).map((u) => u.id),
+      ...(t.deleted || []).map((u) => u.id),
+      ...(t.updated || []).map(({ oldValue: u }) => u.id)
+    ]);
+    return !!(Array.isArray(e.options.annotations) ? e.options.annotations : [e.options.annotations]).find((u) => E.has(u));
+  } else
+    return !0;
+}, se = (e, n) => {
+  const t = new Set((e.created || []).map((s) => s.id)), o = new Set((e.updated || []).map(({ newValue: s }) => s.id)), i = new Set((n.created || []).map((s) => s.id)), p = new Set((n.deleted || []).map((s) => s.id)), U = new Set((n.updated || []).map(({ oldValue: s }) => s.id)), E = new Set((n.updated || []).filter(({ oldValue: s }) => t.has(s.id) || o.has(s.id)).map(({ oldValue: s }) => s.id)), w = [
+    ...(e.created || []).filter((s) => !p.has(s.id)).map((s) => U.has(s.id) ? n.updated.find(({ oldValue: h }) => h.id === s.id).newValue : s),
+    ...n.created || []
+  ], u = [
+    ...(e.deleted || []).filter((s) => !i.has(s.id)),
+    ...(n.deleted || []).filter((s) => !t.has(s.id))
+  ], L = [
+    ...(e.updated || []).filter(({ newValue: s }) => !p.has(s.id)).map((s) => {
+      const { oldValue: h, newValue: C } = s;
+      if (U.has(C.id)) {
+        const b = n.updated.find((S) => S.oldValue.id === C.id).newValue;
+        return M(h, b);
+      } else
+        return s;
+    }),
+    ...(n.updated || []).filter(({ oldValue: s }) => !E.has(s.id))
+  ];
+  return { created: w, deleted: u, updated: L };
+}, ie = (e) => e.id !== void 0, Ue = () => {
+  const e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), t = [], o = (d, l = {}) => t.push({ onChange: d, options: l }), i = (d) => {
+    const l = t.findIndex((a) => a.onChange == d);
+    l > -1 && t.splice(l, 1);
+  }, p = (d, l) => {
+    const a = {
+      origin: d,
+      changes: {
+        created: l.created || [],
+        updated: l.updated || [],
+        deleted: l.deleted || []
+      },
+      state: [...e.values()]
+    };
+    t.forEach((f) => {
+      oe(f, a) && f.onChange(a);
+    });
+  }, U = (d, l = O.LOCAL) => {
+    if (e.get(d.id))
+      throw Error(`Cannot add annotation ${d.id} - exists already`);
+    e.set(d.id, d), d.bodies.forEach((f) => n.set(f.id, d.id)), p(l, { created: [d] });
+  }, E = (d, l) => {
+    const a = typeof d == "string" ? l : d, f = typeof d == "string" ? d : d.id, v = e.get(f);
+    if (v) {
+      const T = M(v, a);
+      return f === a.id ? e.set(f, a) : (e.delete(f), e.set(a.id, a)), v.bodies.forEach((B) => n.delete(B.id)), a.bodies.forEach((B) => n.set(B.id, a.id)), T;
+    } else
+      console.warn(`Cannot update annotation ${f} - does not exist`);
+  }, w = (d, l = O.LOCAL, a = O.LOCAL) => {
+    const f = ie(l) ? a : l, v = E(d, l);
+    v && p(f, { updated: [v] });
+  }, u = (d, l = O.LOCAL) => {
+    const a = d.reduce((f, v) => {
+      const T = E(v);
+      return T ? [...f, T] : f;
+    }, []);
+    a.length > 0 && p(l, { updated: a });
+  }, L = (d, l = O.LOCAL) => {
+    const a = e.get(d.annotation);
+    if (a) {
+      const f = {
+        ...a,
+        bodies: [...a.bodies, d]
+      };
+      e.set(a.id, f), n.set(d.id, f.id), p(l, { updated: [{
+        oldValue: a,
+        newValue: f,
+        bodiesCreated: [d]
+      }] });
+    } else
+      console.warn(`Attempt to add body to missing annotation: ${d.annotation}`);
+  }, s = () => [...e.values()], h = (d = O.LOCAL) => {
+    const l = [...e.values()];
+    e.clear(), n.clear(), p(d, { deleted: l });
+  }, C = (d, l = !0, a = O.LOCAL) => {
+    if (l) {
+      const f = [...e.values()];
+      e.clear(), n.clear(), d.forEach((v) => {
+        e.set(v.id, v), v.bodies.forEach((T) => n.set(T.id, v.id));
+      }), p(a, { created: d, deleted: f });
+    } else {
+      const f = d.reduce((v, T) => {
+        const B = e.get(T.id);
+        return B ? [...v, B] : v;
+      }, []);
+      if (f.length > 0)
+        throw Error(`Bulk insert would overwrite the following annotations: ${f.map((v) => v.id).join(", ")}`);
+      d.forEach((v) => {
+        e.set(v.id, v), v.bodies.forEach((T) => n.set(T.id, v.id));
+      }), p(a, { created: d });
+    }
+  }, b = (d) => {
+    const l = typeof d == "string" ? d : d.id, a = e.get(l);
+    if (a)
+      return e.delete(l), a.bodies.forEach((f) => n.delete(f.id)), a;
+    console.warn(`Attempt to delete missing annotation: ${l}`);
+  }, S = (d, l = O.LOCAL) => {
+    const a = b(d);
+    a && p(l, { deleted: [a] });
+  }, y = (d, l = O.LOCAL) => {
+    const a = d.reduce((f, v) => {
+      const T = b(v);
+      return T ? [...f, T] : f;
+    }, []);
+    a.length > 0 && p(l, { deleted: a });
+  }, c = (d, l = O.LOCAL) => {
+    const a = e.get(d.annotation);
+    if (a) {
+      const f = a.bodies.find((v) => v.id === d.id);
+      if (f) {
+        n.delete(f.id);
+        const v = {
+          ...a,
+          bodies: a.bodies.filter((B) => B.id !== d.id)
+        };
+        e.set(a.id, v), p(l, { updated: [{
+          oldValue: a,
+          newValue: v,
+          bodiesDeleted: [f]
+        }] });
+      } else
+        console.warn(`Attempt to delete missing body ${d.id} from annotation ${d.annotation}`);
+    } else
+      console.warn(`Attempt to delete body from missing annotation ${d.annotation}`);
+  }, g = (d) => {
+    const l = e.get(d);
+    return l ? { ...l } : void 0;
+  }, r = (d) => {
+    const l = n.get(d);
+    if (l) {
+      const f = g(l).bodies.find((v) => v.id === d);
+      if (f)
+        return f;
+      console.error(`Store integrity error: body ${d} in index, but not in annotation`);
+    } else
+      console.warn(`Attempt to retrieve missing body: ${d}`);
+  }, A = (d, l) => {
+    if (d.annotation !== l.annotation)
+      throw "Annotation integrity violation: annotation ID must be the same when updating bodies";
+    const a = e.get(d.annotation);
+    if (a) {
+      const f = a.bodies.find((T) => T.id === d.id), v = {
+        ...a,
+        bodies: a.bodies.map((T) => T.id === f.id ? l : T)
+      };
+      return e.set(a.id, v), f.id !== l.id && (n.delete(f.id), n.set(l.id, v.id)), {
+        oldValue: a,
+        newValue: v,
+        bodiesUpdated: [{ oldBody: f, newBody: l }]
+      };
+    } else
+      console.warn(`Attempt to add body to missing annotation ${d.annotation}`);
+  }, m = (d, l, a = O.LOCAL) => {
+    const f = A(d, l);
+    f && p(a, { updated: [f] });
+  }, R = (d, l = O.LOCAL) => {
+    const a = d.map((f) => A({ id: f.id, annotation: f.annotation }, f)).filter(Boolean);
+    p(l, { updated: a });
+  }, I = (d) => {
+    const l = e.get(d.annotation);
+    if (l) {
+      const a = {
+        ...l,
+        target: {
+          ...l.target,
+          ...d
+        }
+      };
+      return e.set(l.id, a), {
+        oldValue: l,
+        newValue: a,
+        targetUpdated: {
+          oldTarget: l.target,
+          newTarget: d
+        }
+      };
+    } else
+      console.warn(`Attempt to update target on missing annotation: ${d.annotation}`);
+  };
+  return {
+    addAnnotation: U,
+    addBody: L,
+    all: s,
+    bulkAddAnnotation: C,
+    bulkDeleteAnnotation: y,
+    bulkUpdateAnnotation: u,
+    bulkUpdateBodies: R,
+    bulkUpdateTargets: (d, l = O.LOCAL) => {
+      const a = d.map((f) => I(f)).filter(Boolean);
+      a.length > 0 && p(l, { updated: a });
+    },
+    clear: h,
+    deleteAnnotation: S,
+    deleteBody: c,
+    getAnnotation: g,
+    getBody: r,
+    observe: o,
+    unobserve: i,
+    updateAnnotation: w,
+    updateBody: m,
+    updateTarget: (d, l = O.LOCAL) => {
+      const a = I(d);
+      a && p(l, { updated: [a] });
+    }
+  };
+}, Le = (e) => ({
+  ...e,
+  subscribe: (t) => {
+    const o = (i) => t(i.state);
+    return e.observe(o), t(e.all()), () => e.unobserve(o);
+  }
+});
+let P = () => ({
+  emit(e, ...n) {
+    for (let t = 0, o = this.events[e] || [], i = o.length; t < i; t++)
+      o[t](...n);
+  },
+  events: {},
+  on(e, n) {
+    var t;
+    return ((t = this.events)[e] || (t[e] = [])).push(n), () => {
+      var o;
+      this.events[e] = (o = this.events[e]) == null ? void 0 : o.filter((i) => n !== i);
+    };
+  }
+});
+const de = 250, Se = (e) => {
+  const n = P(), t = [];
+  let o = -1, i = !1, p = 0;
+  const U = (r) => {
+    if (!i) {
+      const { changes: A } = r, m = performance.now();
+      if (m - p > de)
+        t.splice(o + 1), t.push(A), o = t.length - 1;
+      else {
+        const R = t.length - 1;
+        t[R] = se(t[R], A);
+      }
+      p = m;
+    }
+    i = !1;
+  };
+  e.observe(U, { origin: O.LOCAL });
+  const E = (r) => r && r.length > 0 && e.bulkDeleteAnnotation(r), w = (r) => r && r.length > 0 && e.bulkAddAnnotation(r, !1), u = (r) => r && r.length > 0 && e.bulkUpdateAnnotation(r.map(({ oldValue: A }) => A)), L = (r) => r && r.length > 0 && e.bulkUpdateAnnotation(r.map(({ newValue: A }) => A)), s = (r) => r && r.length > 0 && e.bulkAddAnnotation(r, !1), h = (r) => r && r.length > 0 && e.bulkDeleteAnnotation(r);
+  return {
+    canRedo: () => t.length - 1 > o,
+    canUndo: () => o > -1,
+    destroy: () => e.unobserve(U),
+    on: (r, A) => n.on(r, A),
+    redo: () => {
+      if (t.length - 1 > o) {
+        i = !0;
+        const { created: r, updated: A, deleted: m } = t[o + 1];
+        w(r), L(A), h(m), n.emit("redo", t[o + 1]), o += 1;
+      }
+    },
+    undo: () => {
+      if (o > -1) {
+        i = !0;
+        const { created: r, updated: A, deleted: m } = t[o];
+        E(r), u(A), s(m), n.emit("undo", t[o]), o -= 1;
+      }
+    }
+  };
+}, Oe = () => {
+  const { subscribe: e, set: n } = Y([]);
+  return {
+    subscribe: e,
+    set: n
+  };
+}, Te = (e, n, t, o) => {
+  const { store: i, selection: p, hover: U, viewport: E } = e, w = /* @__PURE__ */ new Map();
+  let u = [], L, s;
+  const h = (c, g) => {
+    w.has(c) ? w.get(c).push(g) : w.set(c, [g]);
+  }, C = (c, g) => {
+    const r = w.get(c);
+    r && r.indexOf(g) > 0 && r.splice(r.indexOf(g), 1);
+  }, b = (c, g, r) => {
+    w.has(c) && setTimeout(() => {
+      w.get(c).forEach((A) => {
+        if (t) {
+          const m = Array.isArray(g) ? g.map((I) => t.serialize(I)) : t.serialize(g), R = r ? r instanceof PointerEvent ? r : t.serialize(r) : void 0;
+          A(m, R);
+        } else
+          A(g, r);
+      });
+    }, 1);
+  }, S = () => {
+    const { selected: c } = p, g = (c || []).map(({ id: r }) => i.getAnnotation(r));
+    g.forEach((r) => {
+      const A = u.find((m) => m.id === r.id);
+      (!A || !x(A, r)) && b("updateAnnotation", r, A);
+    }), u = u.map((r) => {
+      const A = g.find(({ id: m }) => m === r.id);
+      return A || r;
+    });
+  };
+  p.subscribe(({ selected: c }) => {
+    if (!(u.length === 0 && c.length === 0)) {
+      if (u.length === 0 && c.length > 0)
+        u = c.map(({ id: g }) => i.getAnnotation(g));
+      else if (u.length > 0 && c.length === 0)
+        u.forEach((g) => {
+          const r = i.getAnnotation(g.id);
+          r && !x(r, g) && b("updateAnnotation", r, g);
+        }), u = [];
+      else {
+        const g = new Set(u.map((m) => m.id)), r = new Set(c.map(({ id: m }) => m));
+        u.filter((m) => !r.has(m.id)).forEach((m) => {
+          const R = i.getAnnotation(m.id);
+          R && !x(R, m) && b("updateAnnotation", R, m);
+        }), u = [
+          // Remove annotations that were deselected
+          ...u.filter((m) => r.has(m.id)),
+          // Add editable annotations that were selected
+          ...c.filter(({ id: m }) => !g.has(m)).map(({ id: m }) => i.getAnnotation(m))
+        ];
+      }
+      b("selectionChanged", u);
+    }
+  }), U.subscribe((c) => {
+    !L && c ? b("mouseEnterAnnotation", i.getAnnotation(c)) : L && !c ? b("mouseLeaveAnnotation", i.getAnnotation(L)) : L && c && (b("mouseLeaveAnnotation", i.getAnnotation(L)), b("mouseEnterAnnotation", i.getAnnotation(c))), L = c;
+  }), E == null || E.subscribe((c) => b("viewportIntersect", c.map((g) => i.getAnnotation(g)))), i.observe((c) => {
+    o && (s && clearTimeout(s), s = setTimeout(S, 1e3));
+    const { created: g, deleted: r } = c.changes;
+    (g || []).forEach((m) => b("createAnnotation", m)), (r || []).forEach((m) => b("deleteAnnotation", m)), (c.changes.updated || []).filter((m) => [
+      ...m.bodiesCreated || [],
+      ...m.bodiesDeleted || [],
+      ...m.bodiesUpdated || []
+    ].length > 0).forEach(({ oldValue: m, newValue: R }) => {
+      const I = u.find((N) => N.id === m.id) || m;
+      u = u.map((N) => N.id === m.id ? R : N), b("updateAnnotation", R, I);
+    });
+  }, { origin: O.LOCAL }), i.observe((c) => {
+    if (u) {
+      const g = new Set(u.map((A) => A.id)), r = (c.changes.updated || []).filter(({ newValue: A }) => g.has(A.id)).map(({ newValue: A }) => A);
+      r.length > 0 && (u = u.map((A) => {
+        const m = r.find((R) => R.id === A.id);
+        return m || A;
+      }));
+    }
+  }, { origin: O.REMOTE });
+  const y = (c) => (g) => {
+    const { updated: r } = g;
+    c ? (r || []).forEach((A) => b("updateAnnotation", A.oldValue, A.newValue)) : (r || []).forEach((A) => b("updateAnnotation", A.newValue, A.oldValue));
+  };
+  return n.on("undo", y(!0)), n.on("redo", y(!1)), { on: h, off: C, emit: b };
+}, De = (e) => (n) => n.map((t) => e.serialize(t)), re = (e) => (n) => n.reduce((t, o) => {
+  const { parsed: i, error: p } = e.parse(o);
+  return p ? {
+    parsed: t.parsed,
+    failed: [...t.failed, o]
+  } : i ? {
+    parsed: [...t.parsed, i],
+    failed: t.failed
+  } : {
+    ...t
+  };
+}, { parsed: [], failed: [] }), Re = (e, n, t) => {
+  const { store: o, selection: i } = e, p = (y) => {
+    if (t) {
+      const { parsed: c, error: g } = t.parse(y);
+      c ? o.addAnnotation(c, O.REMOTE) : console.error(g);
+    } else
+      o.addAnnotation(y, O.REMOTE);
+  }, U = () => i.clear(), E = () => o.clear(), w = (y) => {
+    const c = o.getAnnotation(y);
+    return t && c ? t.serialize(c) : c;
+  }, u = () => t ? o.all().map(t.serialize) : o.all(), L = () => {
+    var g;
+    const c = (((g = i.selected) == null ? void 0 : g.map((r) => r.id)) || []).map((r) => o.getAnnotation(r)).filter(Boolean);
+    return t ? c.map(t.serialize) : c;
+  }, s = (y, c = !0) => fetch(y).then((g) => g.json()).then((g) => (C(g, c), g)), h = (y) => {
+    if (typeof y == "string") {
+      const c = o.getAnnotation(y);
+      if (o.deleteAnnotation(y), c)
+        return t ? t.serialize(c) : c;
+    } else {
+      const c = t ? t.parse(y).parsed : y;
+      if (c)
+        return o.deleteAnnotation(c), y;
+    }
+  }, C = (y, c = !0) => {
+    if (t) {
+      const { parsed: g, failed: r } = re(t)(y);
+      r.length > 0 && console.warn(`Discarded ${r.length} invalid annotations`, r), o.bulkAddAnnotation(g, c, O.REMOTE);
+    } else
+      o.bulkAddAnnotation(y, c, O.REMOTE);
+  }, b = (y) => {
+    y ? i.setSelected(y) : i.clear();
+  }, S = (y) => {
+    if (t) {
+      const c = t.parse(y).parsed, g = t.serialize(o.getAnnotation(c.id));
+      return o.updateAnnotation(c), g;
+    } else {
+      const c = o.getAnnotation(y.id);
+      return o.updateAnnotation(y), c;
+    }
+  };
+  return {
+    addAnnotation: p,
+    cancelSelected: U,
+    canRedo: n.canRedo,
+    canUndo: n.canUndo,
+    clearAnnotations: E,
+    getAnnotationById: w,
+    getAnnotations: u,
+    getSelected: L,
+    loadAnnotations: s,
+    redo: n.redo,
+    removeAnnotation: h,
+    setAnnotations: C,
+    setSelected: b,
+    undo: n.undo,
+    updateAnnotation: S
+  };
+}, ae = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+let ce = (e) => crypto.getRandomValues(new Uint8Array(e)), le = (e, n, t) => {
+  let o = (2 << Math.log(e.length - 1) / Math.LN2) - 1, i = -~(1.6 * o * n / e.length);
+  return (p = n) => {
+    let U = "";
+    for (; ; ) {
+      let E = t(i), w = i;
+      for (; w--; )
+        if (U += e[E[w] & o] || "", U.length === p)
+          return U;
+    }
+  };
+}, ue = (e, n = 21) => le(e, n, ce), fe = (e = 21) => {
+  let n = "", t = crypto.getRandomValues(new Uint8Array(e));
+  for (; e--; )
+    n += ae[t[e] & 63];
+  return n;
+};
+const Be = () => ({ isGuest: !0, id: ue("1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", 20)() }), pe = (e) => {
+  const n = JSON.stringify(e);
+  let t = 0;
+  for (let o = 0, i = n.length; o < i; o++) {
+    let p = n.charCodeAt(o);
+    t = (t << 5) - t + p, t |= 0;
+  }
+  return `${t}`;
+}, he = (e) => e ? typeof e == "object" ? { ...e } : e : void 0, xe = (e, n) => (Array.isArray(e) ? e : [e]).map((t) => {
+  const { id: o, type: i, purpose: p, value: U, created: E, creator: w, ...u } = t;
+  return {
+    id: o || `temp-${pe(t)}`,
+    annotation: n,
+    type: i,
+    purpose: p,
+    value: U,
+    created: E ? new Date(E) : void 0,
+    creator: he(w),
+    ...u
+  };
+}), Ie = (e) => e.map((n) => {
+  var o, i;
+  const t = { ...n };
+  return delete t.annotation, (o = t.id) != null && o.startsWith("temp-") && delete t.id, { ...t, created: (i = t.created) == null ? void 0 : i.toISOString() };
+}), ge = [
+  "#ff7c00",
+  // orange
+  "#1ac938",
+  // green
+  "#e8000b",
+  // red
+  "#8b2be2",
+  // purple
+  "#9f4800",
+  // brown
+  "#f14cc1",
+  // pink
+  "#ffc400",
+  // khaki
+  "#00d7ff",
+  // cyan
+  "#023eff"
+  // blue
+], me = () => {
+  const e = [...ge];
+  return { assignRandomColor: () => {
+    const o = Math.floor(Math.random() * e.length), i = e[o];
+    return e.splice(o, 1), i;
+  }, releaseColor: (o) => e.push(o) };
+}, Ae = () => {
+  const e = me();
+  return { addUser: (o, i) => {
+    const p = e.assignRandomColor();
+    return {
+      label: i.name || i.id,
+      avatar: i.avatar,
+      color: p
+    };
+  }, removeUser: (o) => e.releaseColor(o.appearance.color) };
+}, be = (e, n) => e.every((t) => e.includes(t)) && n.every((t) => e.includes(t)), ke = fe(), Ne = (e = Ae()) => {
+  const n = P(), t = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), i = (s, h) => {
+    if (t.has(s)) {
+      console.warn("Attempt to add user that is already present", s, h);
+      return;
+    }
+    const C = e.addUser(s, h);
+    t.set(s, {
+      ...h,
+      presenceKey: s,
+      appearance: C
+    });
+  }, p = (s) => {
+    const h = t.get(s);
+    if (!h) {
+      console.warn("Attempt to remove user that is not present", s);
+      return;
+    }
+    e.removeUser(h), t.delete(s);
+  }, U = (s) => {
+    const h = new Set(s.map((S) => S.presenceKey)), C = s.filter(({ presenceKey: S }) => !t.has(S)), b = Array.from(t.values()).filter((S) => !h.has(S.presenceKey));
+    C.forEach(({ presenceKey: S, user: y }) => i(S, y)), b.forEach((S) => {
+      const { presenceKey: y } = S;
+      o.has(y) && n.emit("selectionChange", S, null), p(y);
+    }), (C.length > 0 || b.length > 0) && n.emit("presence", u());
+  }, E = (s, h) => {
+    const C = t.get(s);
+    if (!C) {
+      console.warn("Activity notification from user that is not present");
+      return;
+    }
+    const b = o.get(s);
+    (!b || !be(b, h)) && (o.set(s, h), n.emit("selectionChange", C, h));
+  }, w = (s, h) => {
+    const C = t.get(s);
+    if (!C) {
+      console.warn("Selection change for user that is not present", s);
+      return;
+    }
+    h ? o.set(s, h) : o.delete(s), n.emit("selectionChange", C, h);
+  }, u = () => [...Array.from(t.values())];
+  return {
+    getPresentUsers: u,
+    notifyActivity: E,
+    on: (s, h) => n.on(s, h),
+    syncUsers: U,
+    updateSelection: w
+  };
+};
+export {
+  ne as Ignore,
+  O as Origin,
+  ke as PRESENCE_KEY,
+  q as PointerSelectAction,
+  Be as createAnonymousGuest,
+  Re as createBaseAnnotator,
+  Ce as createBody,
+  Ae as createDefaultAppearenceProvider,
+  ve as createHoverState,
+  Te as createLifecyleObserver,
+  Ne as createPresenceState,
+  ye as createSelectionState,
+  Ue as createStore,
+  Se as createUndoStack,
+  Oe as createViewportState,
+  me as defaultColorProvider,
+  M as diffAnnotations,
+  we as getContributors,
+  se as mergeChanges,
+  G as onPointerSelect,
+  re as parseAll,
+  xe as parseW3CBodies,
+  he as parseW3CUser,
+  De as serializeAll,
+  Ie as serializeW3CBodies,
+  oe as shouldNotify,
+  Le as toSvelteStore
+};
+//# sourceMappingURL=annotorious-core.es.js.map