@annotorious/react 3.1.4 → 3.1.6

package/dist/annotorious-react.es22.js

@@ -1,268 +1,268 @@
-import { evaluate as Y, getSide as F, getSideAxis as M, getOppositePlacement as Q, getExpandedPlacements as U, getOppositeAxisPlacements as Z, getAlignmentSides as ee, rectToClientRect as $, getPaddingObject as H, clamp as _, getAlignmentAxis as q, getAlignment as I, min as X, max as z, getOppositeAxis as te, getAxisLength as G } from "./annotorious-react.es21.js";
-function W(s, c, l) {
+import { evaluate as Y, rectToClientRect as $, getPaddingObject as H, getSide as F, getSideAxis as M, getOppositePlacement as Q, getExpandedPlacements as U, getOppositeAxisPlacements as Z, getAlignmentSides as tt, clamp as _, min as X, max as z, getAlignment as I, getOppositeAxis as et, getAlignmentAxis as q, getAxisLength as G } from "./annotorious-react.es21.js";
+function W(o, c, l) {
   let {
-    reference: t,
-    floating: o
-  } = s;
-  const e = M(c), a = q(c), r = G(a), d = F(c), u = e === "y", g = t.x + t.width / 2 - o.width / 2, i = t.y + t.height / 2 - o.height / 2, m = t[r] / 2 - o[r] / 2;
+    reference: e,
+    floating: s
+  } = o;
+  const t = M(c), a = q(c), r = G(a), d = F(c), g = t === "y", u = e.x + e.width / 2 - s.width / 2, i = e.y + e.height / 2 - s.height / 2, m = e[r] / 2 - s[r] / 2;
   let n;
   switch (d) {
     case "top":
       n = {
-        x: g,
-        y: t.y - o.height
+        x: u,
+        y: e.y - s.height
       };
       break;
     case "bottom":
       n = {
-        x: g,
-        y: t.y + t.height
+        x: u,
+        y: e.y + e.height
       };
       break;
     case "right":
       n = {
-        x: t.x + t.width,
+        x: e.x + e.width,
         y: i
       };
       break;
     case "left":
       n = {
-        x: t.x - o.width,
+        x: e.x - s.width,
         y: i
       };
       break;
     default:
       n = {
-        x: t.x,
-        y: t.y
+        x: e.x,
+        y: e.y
       };
   }
   switch (I(c)) {
     case "start":
-      n[a] -= m * (l && u ? -1 : 1);
+      n[a] -= m * (l && g ? -1 : 1);
       break;
     case "end":
-      n[a] += m * (l && u ? -1 : 1);
+      n[a] += m * (l && g ? -1 : 1);
       break;
   }
   return n;
 }
-const oe = async (s, c, l) => {
+const st = async (o, c, l) => {
   const {
-    placement: t = "bottom",
-    strategy: o = "absolute",
-    middleware: e = [],
+    placement: e = "bottom",
+    strategy: s = "absolute",
+    middleware: t = [],
     platform: a
-  } = l, r = e.filter(Boolean), d = await (a.isRTL == null ? void 0 : a.isRTL(c));
-  let u = await a.getElementRects({
-    reference: s,
+  } = l, r = t.filter(Boolean), d = await (a.isRTL == null ? void 0 : a.isRTL(c));
+  let g = await a.getElementRects({
+    reference: o,
     floating: c,
-    strategy: o
+    strategy: s
   }), {
-    x: g,
+    x: u,
     y: i
-  } = W(u, t, d), m = t, n = {}, f = 0;
+  } = W(g, e, d), m = e, n = {}, f = 0;
   for (let h = 0; h < r.length; h++) {
     const {
       name: x,
       fn: w
     } = r[h], {
-      x: b,
+      x: A,
       y,
-      data: P,
+      data: R,
       reset: p
     } = await w({
-      x: g,
+      x: u,
       y: i,
-      initialPlacement: t,
+      initialPlacement: e,
       placement: m,
-      strategy: o,
+      strategy: s,
       middlewareData: n,
-      rects: u,
+      rects: g,
       platform: a,
       elements: {
-        reference: s,
+        reference: o,
         floating: c
       }
     });
-    g = b ?? g, i = y ?? i, n = {
+    u = A ?? u, i = y ?? i, n = {
       ...n,
       [x]: {
         ...n[x],
-        ...P
+        ...R
       }
-    }, p && f <= 50 && (f++, typeof p == "object" && (p.placement && (m = p.placement), p.rects && (u = p.rects === !0 ? await a.getElementRects({
-      reference: s,
+    }, p && f <= 50 && (f++, typeof p == "object" && (p.placement && (m = p.placement), p.rects && (g = p.rects === !0 ? await a.getElementRects({
+      reference: o,
       floating: c,
-      strategy: o
+      strategy: s
     }) : p.rects), {
-      x: g,
+      x: u,
       y: i
-    } = W(u, m, d)), h = -1);
+    } = W(g, m, d)), h = -1);
   }
   return {
-    x: g,
+    x: u,
     y: i,
     placement: m,
-    strategy: o,
+    strategy: s,
     middlewareData: n
   };
 };
-async function J(s, c) {
+async function J(o, c) {
   var l;
   c === void 0 && (c = {});
   const {
-    x: t,
-    y: o,
-    platform: e,
+    x: e,
+    y: s,
+    platform: t,
     rects: a,
     elements: r,
     strategy: d
-  } = s, {
-    boundary: u = "clippingAncestors",
-    rootBoundary: g = "viewport",
+  } = o, {
+    boundary: g = "clippingAncestors",
+    rootBoundary: u = "viewport",
     elementContext: i = "floating",
     altBoundary: m = !1,
     padding: n = 0
-  } = Y(c, s), f = H(n), x = r[m ? i === "floating" ? "reference" : "floating" : i], w = $(await e.getClippingRect({
-    element: (l = await (e.isElement == null ? void 0 : e.isElement(x))) == null || l ? x : x.contextElement || await (e.getDocumentElement == null ? void 0 : e.getDocumentElement(r.floating)),
-    boundary: u,
-    rootBoundary: g,
+  } = Y(c, o), f = H(n), x = r[m ? i === "floating" ? "reference" : "floating" : i], w = $(await t.getClippingRect({
+    element: (l = await (t.isElement == null ? void 0 : t.isElement(x))) == null || l ? x : x.contextElement || await (t.getDocumentElement == null ? void 0 : t.getDocumentElement(r.floating)),
+    boundary: g,
+    rootBoundary: u,
     strategy: d
-  })), b = i === "floating" ? {
-    x: t,
-    y: o,
+  })), A = i === "floating" ? {
+    x: e,
+    y: s,
     width: a.floating.width,
     height: a.floating.height
-  } : a.reference, y = await (e.getOffsetParent == null ? void 0 : e.getOffsetParent(r.floating)), P = await (e.isElement == null ? void 0 : e.isElement(y)) ? await (e.getScale == null ? void 0 : e.getScale(y)) || {
+  } : a.reference, y = await (t.getOffsetParent == null ? void 0 : t.getOffsetParent(r.floating)), R = await (t.isElement == null ? void 0 : t.isElement(y)) ? await (t.getScale == null ? void 0 : t.getScale(y)) || {
     x: 1,
     y: 1
   } : {
     x: 1,
     y: 1
-  }, p = $(e.convertOffsetParentRelativeRectToViewportRelativeRect ? await e.convertOffsetParentRelativeRectToViewportRelativeRect({
+  }, p = $(t.convertOffsetParentRelativeRectToViewportRelativeRect ? await t.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements: r,
-    rect: b,
+    rect: A,
     offsetParent: y,
     strategy: d
-  }) : b);
+  }) : A);
   return {
-    top: (w.top - p.top + f.top) / P.y,
-    bottom: (p.bottom - w.bottom + f.bottom) / P.y,
-    left: (w.left - p.left + f.left) / P.x,
-    right: (p.right - w.right + f.right) / P.x
+    top: (w.top - p.top + f.top) / R.y,
+    bottom: (p.bottom - w.bottom + f.bottom) / R.y,
+    left: (w.left - p.left + f.left) / R.x,
+    right: (p.right - w.right + f.right) / R.x
   };
 }
-const ce = (s) => ({
+const ct = (o) => ({
   name: "arrow",
-  options: s,
+  options: o,
   async fn(c) {
     const {
       x: l,
-      y: t,
-      placement: o,
-      rects: e,
+      y: e,
+      placement: s,
+      rects: t,
       platform: a,
       elements: r,
       middlewareData: d
     } = c, {
-      element: u,
-      padding: g = 0
-    } = Y(s, c) || {};
-    if (u == null)
+      element: g,
+      padding: u = 0
+    } = Y(o, c) || {};
+    if (g == null)
       return {};
-    const i = H(g), m = {
+    const i = H(u), m = {
       x: l,
-      y: t
-    }, n = q(o), f = G(n), h = await a.getDimensions(u), x = n === "y", w = x ? "top" : "left", b = x ? "bottom" : "right", y = x ? "clientHeight" : "clientWidth", P = e.reference[f] + e.reference[n] - m[n] - e.floating[f], p = m[n] - e.reference[n], C = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(u));
+      y: e
+    }, n = q(s), f = G(n), h = await a.getDimensions(g), x = n === "y", w = x ? "top" : "left", A = x ? "bottom" : "right", y = x ? "clientHeight" : "clientWidth", R = t.reference[f] + t.reference[n] - m[n] - t.floating[f], p = m[n] - t.reference[n], C = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(g));
     let k = C ? C[y] : 0;
-    (!k || !await (a.isElement == null ? void 0 : a.isElement(C))) && (k = r.floating[y] || e.floating[f]);
-    const j = P / 2 - p / 2, T = k / 2 - h[f] / 2 - 1, A = X(i[w], T), L = X(i[b], T), S = A, B = k - h[f] - L, R = k / 2 - h[f] / 2 + j, D = _(S, R, B), v = !d.arrow && I(o) != null && R !== D && e.reference[f] / 2 - (R < S ? A : L) - h[f] / 2 < 0, O = v ? R < S ? R - S : R - B : 0;
+    (!k || !await (a.isElement == null ? void 0 : a.isElement(C))) && (k = r.floating[y] || t.floating[f]);
+    const j = R / 2 - p / 2, T = k / 2 - h[f] / 2 - 1, v = X(i[w], T), L = X(i[A], T), S = v, B = k - h[f] - L, b = k / 2 - h[f] / 2 + j, D = _(S, b, B), P = !d.arrow && I(s) != null && b !== D && t.reference[f] / 2 - (b < S ? v : L) - h[f] / 2 < 0, O = P ? b < S ? b - S : b - B : 0;
     return {
       [n]: m[n] + O,
       data: {
         [n]: D,
-        centerOffset: R - D - O,
-        ...v && {
+        centerOffset: b - D - O,
+        ...P && {
           alignmentOffset: O
         }
       },
-      reset: v
+      reset: P
     };
   }
-}), le = function(s) {
-  return s === void 0 && (s = {}), {
+}), lt = function(o) {
+  return o === void 0 && (o = {}), {
     name: "flip",
-    options: s,
+    options: o,
     async fn(c) {
-      var l, t;
+      var l, e;
       const {
-        placement: o,
-        middlewareData: e,
+        placement: s,
+        middlewareData: t,
         rects: a,
         initialPlacement: r,
         platform: d,
-        elements: u
+        elements: g
       } = c, {
-        mainAxis: g = !0,
+        mainAxis: u = !0,
         crossAxis: i = !0,
         fallbackPlacements: m,
         fallbackStrategy: n = "bestFit",
         fallbackAxisSideDirection: f = "none",
         flipAlignment: h = !0,
         ...x
-      } = Y(s, c);
-      if ((l = e.arrow) != null && l.alignmentOffset)
+      } = Y(o, c);
+      if ((l = t.arrow) != null && l.alignmentOffset)
         return {};
-      const w = F(o), b = M(r), y = F(r) === r, P = await (d.isRTL == null ? void 0 : d.isRTL(u.floating)), p = m || (y || !h ? [Q(r)] : U(r)), C = f !== "none";
-      !m && C && p.push(...Z(r, h, f, P));
+      const w = F(s), A = M(r), y = F(r) === r, R = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), p = m || (y || !h ? [Q(r)] : U(r)), C = f !== "none";
+      !m && C && p.push(...Z(r, h, f, R));
       const k = [r, ...p], j = await J(c, x), T = [];
-      let A = ((t = e.flip) == null ? void 0 : t.overflows) || [];
-      if (g && T.push(j[w]), i) {
-        const R = ee(o, a, P);
-        T.push(j[R[0]], j[R[1]]);
+      let v = ((e = t.flip) == null ? void 0 : e.overflows) || [];
+      if (u && T.push(j[w]), i) {
+        const b = tt(s, a, R);
+        T.push(j[b[0]], j[b[1]]);
       }
-      if (A = [...A, {
-        placement: o,
+      if (v = [...v, {
+        placement: s,
         overflows: T
-      }], !T.every((R) => R <= 0)) {
+      }], !T.every((b) => b <= 0)) {
         var L, S;
-        const R = (((L = e.flip) == null ? void 0 : L.index) || 0) + 1, D = k[R];
+        const b = (((L = t.flip) == null ? void 0 : L.index) || 0) + 1, D = k[b];
         if (D)
           return {
             data: {
-              index: R,
-              overflows: A
+              index: b,
+              overflows: v
             },
             reset: {
               placement: D
             }
           };
-        let v = (S = A.filter((O) => O.overflows[0] <= 0).sort((O, E) => O.overflows[1] - E.overflows[1])[0]) == null ? void 0 : S.placement;
-        if (!v)
+        let P = (S = v.filter((O) => O.overflows[0] <= 0).sort((O, E) => O.overflows[1] - E.overflows[1])[0]) == null ? void 0 : S.placement;
+        if (!P)
           switch (n) {
             case "bestFit": {
               var B;
-              const O = (B = A.filter((E) => {
+              const O = (B = v.filter((E) => {
                 if (C) {
                   const V = M(E.placement);
-                  return V === b || // Create a bias to the `y` side axis due to horizontal
+                  return V === A || // Create a bias to the `y` side axis due to horizontal
                   // reading directions favoring greater width.
                   V === "y";
                 }
                 return !0;
               }).map((E) => [E.placement, E.overflows.filter((V) => V > 0).reduce((V, N) => V + N, 0)]).sort((E, V) => E[1] - V[1])[0]) == null ? void 0 : B[0];
-              O && (v = O);
+              O && (P = O);
               break;
             }
             case "initialPlacement":
-              v = r;
+              P = r;
               break;
           }
-        if (o !== v)
+        if (s !== P)
           return {
             reset: {
-              placement: v
+              placement: P
             }
           };
       }
@@ -270,79 +270,79 @@ const ce = (s) => ({
     }
   };
 };
-function K(s) {
-  const c = X(...s.map((e) => e.left)), l = X(...s.map((e) => e.top)), t = z(...s.map((e) => e.right)), o = z(...s.map((e) => e.bottom));
+function K(o) {
+  const c = X(...o.map((t) => t.left)), l = X(...o.map((t) => t.top)), e = z(...o.map((t) => t.right)), s = z(...o.map((t) => t.bottom));
   return {
     x: c,
     y: l,
-    width: t - c,
-    height: o - l
+    width: e - c,
+    height: s - l
   };
 }
-function ne(s) {
-  const c = s.slice().sort((o, e) => o.y - e.y), l = [];
-  let t = null;
-  for (let o = 0; o < c.length; o++) {
-    const e = c[o];
-    !t || e.y - t.y > t.height / 2 ? l.push([e]) : l[l.length - 1].push(e), t = e;
+function nt(o) {
+  const c = o.slice().sort((s, t) => s.y - t.y), l = [];
+  let e = null;
+  for (let s = 0; s < c.length; s++) {
+    const t = c[s];
+    !e || t.y - e.y > e.height / 2 ? l.push([t]) : l[l.length - 1].push(t), e = t;
   }
-  return l.map((o) => $(K(o)));
+  return l.map((s) => $(K(s)));
 }
-const ae = function(s) {
-  return s === void 0 && (s = {}), {
+const at = function(o) {
+  return o === void 0 && (o = {}), {
     name: "inline",
-    options: s,
+    options: o,
     async fn(c) {
       const {
         placement: l,
-        elements: t,
-        rects: o,
-        platform: e,
+        elements: e,
+        rects: s,
+        platform: t,
         strategy: a
       } = c, {
         padding: r = 2,
         x: d,
-        y: u
-      } = Y(s, c), g = Array.from(await (e.getClientRects == null ? void 0 : e.getClientRects(t.reference)) || []), i = ne(g), m = $(K(g)), n = H(r);
+        y: g
+      } = Y(o, c), u = Array.from(await (t.getClientRects == null ? void 0 : t.getClientRects(e.reference)) || []), i = nt(u), m = $(K(u)), n = H(r);
       function f() {
-        if (i.length === 2 && i[0].left > i[1].right && d != null && u != null)
-          return i.find((x) => d > x.left - n.left && d < x.right + n.right && u > x.top - n.top && u < x.bottom + n.bottom) || m;
+        if (i.length === 2 && i[0].left > i[1].right && d != null && g != null)
+          return i.find((x) => d > x.left - n.left && d < x.right + n.right && g > x.top - n.top && g < x.bottom + n.bottom) || m;
         if (i.length >= 2) {
           if (M(l) === "y") {
-            const A = i[0], L = i[i.length - 1], S = F(l) === "top", B = A.top, R = L.bottom, D = S ? A.left : L.left, v = S ? A.right : L.right, O = v - D, E = R - B;
+            const v = i[0], L = i[i.length - 1], S = F(l) === "top", B = v.top, b = L.bottom, D = S ? v.left : L.left, P = S ? v.right : L.right, O = P - D, E = b - B;
             return {
               top: B,
-              bottom: R,
+              bottom: b,
               left: D,
-              right: v,
+              right: P,
               width: O,
               height: E,
               x: D,
               y: B
             };
           }
-          const x = F(l) === "left", w = z(...i.map((A) => A.right)), b = X(...i.map((A) => A.left)), y = i.filter((A) => x ? A.left === b : A.right === w), P = y[0].top, p = y[y.length - 1].bottom, C = b, k = w, j = k - C, T = p - P;
+          const x = F(l) === "left", w = z(...i.map((v) => v.right)), A = X(...i.map((v) => v.left)), y = i.filter((v) => x ? v.left === A : v.right === w), R = y[0].top, p = y[y.length - 1].bottom, C = A, k = w, j = k - C, T = p - R;
           return {
-            top: P,
+            top: R,
             bottom: p,
             left: C,
             right: k,
             width: j,
             height: T,
             x: C,
-            y: P
+            y: R
           };
         }
         return m;
       }
-      const h = await e.getElementRects({
+      const h = await t.getElementRects({
         reference: {
           getBoundingClientRect: f
         },
-        floating: t.floating,
+        floating: e.floating,
         strategy: a
       });
-      return o.reference.x !== h.reference.x || o.reference.y !== h.reference.y || o.reference.width !== h.reference.width || o.reference.height !== h.reference.height ? {
+      return s.reference.x !== h.reference.x || s.reference.y !== h.reference.y || s.reference.width !== h.reference.width || s.reference.height !== h.reference.height ? {
         reset: {
           rects: h
         }
@@ -350,12 +350,12 @@ const ae = function(s) {
     }
   };
 };
-async function ie(s, c) {
+async function it(o, c) {
   const {
     placement: l,
-    platform: t,
-    elements: o
-  } = s, e = await (t.isRTL == null ? void 0 : t.isRTL(o.floating)), a = F(l), r = I(l), d = M(l) === "y", u = ["left", "top"].includes(a) ? -1 : 1, g = e && d ? -1 : 1, i = Y(c, s);
+    platform: e,
+    elements: s
+  } = o, t = await (e.isRTL == null ? void 0 : e.isRTL(s.floating)), a = F(l), r = I(l), d = M(l) === "y", g = ["left", "top"].includes(a) ? -1 : 1, u = t && d ? -1 : 1, i = Y(c, o);
   let {
     mainAxis: m,
     crossAxis: n,
@@ -370,28 +370,28 @@ async function ie(s, c) {
     alignmentAxis: i.alignmentAxis
   };
   return r && typeof f == "number" && (n = r === "end" ? f * -1 : f), d ? {
-    x: n * g,
-    y: m * u
+    x: n * u,
+    y: m * g
   } : {
-    x: m * u,
-    y: n * g
+    x: m * g,
+    y: n * u
   };
 }
-const re = function(s) {
-  return s === void 0 && (s = 0), {
+const rt = function(o) {
+  return o === void 0 && (o = 0), {
     name: "offset",
-    options: s,
+    options: o,
     async fn(c) {
-      var l, t;
+      var l, e;
       const {
-        x: o,
-        y: e,
+        x: s,
+        y: t,
         placement: a,
         middlewareData: r
-      } = c, d = await ie(c, s);
-      return a === ((l = r.offset) == null ? void 0 : l.placement) && (t = r.arrow) != null && t.alignmentOffset ? {} : {
-        x: o + d.x,
-        y: e + d.y,
+      } = c, d = await it(c, o);
+      return a === ((l = r.offset) == null ? void 0 : l.placement) && (e = r.arrow) != null && e.alignmentOffset ? {} : {
+        x: s + d.x,
+        y: t + d.y,
         data: {
           ...d,
           placement: a
@@ -399,43 +399,43 @@ const re = function(s) {
       };
     }
   };
-}, fe = function(s) {
-  return s === void 0 && (s = {}), {
+}, ft = function(o) {
+  return o === void 0 && (o = {}), {
     name: "shift",
-    options: s,
+    options: o,
     async fn(c) {
       const {
         x: l,
-        y: t,
-        placement: o
+        y: e,
+        placement: s
       } = c, {
-        mainAxis: e = !0,
+        mainAxis: t = !0,
         crossAxis: a = !1,
         limiter: r = {
           fn: (x) => {
             let {
               x: w,
-              y: b
+              y: A
             } = x;
             return {
               x: w,
-              y: b
+              y: A
             };
           }
         },
         ...d
-      } = Y(s, c), u = {
+      } = Y(o, c), g = {
         x: l,
-        y: t
-      }, g = await J(c, d), i = M(F(o)), m = te(i);
-      let n = u[m], f = u[i];
-      if (e) {
-        const x = m === "y" ? "top" : "left", w = m === "y" ? "bottom" : "right", b = n + g[x], y = n - g[w];
-        n = _(b, n, y);
+        y: e
+      }, u = await J(c, d), i = M(F(s)), m = et(i);
+      let n = g[m], f = g[i];
+      if (t) {
+        const x = m === "y" ? "top" : "left", w = m === "y" ? "bottom" : "right", A = n + u[x], y = n - u[w];
+        n = _(A, n, y);
       }
       if (a) {
-        const x = i === "y" ? "top" : "left", w = i === "y" ? "bottom" : "right", b = f + g[x], y = f - g[w];
-        f = _(b, f, y);
+        const x = i === "y" ? "top" : "left", w = i === "y" ? "bottom" : "right", A = f + u[x], y = f - u[w];
+        f = _(A, f, y);
       }
       const h = r.fn({
         ...c,
@@ -446,9 +446,9 @@ const re = function(s) {
         ...h,
         data: {
           x: h.x - l,
-          y: h.y - t,
+          y: h.y - e,
           enabled: {
-            [m]: e,
+            [m]: t,
             [i]: a
           }
         }
@@ -457,13 +457,13 @@ const re = function(s) {
   };
 };
 export {
-  ce as arrow,
-  oe as computePosition,
+  ct as arrow,
+  st as computePosition,
   J as detectOverflow,
-  le as flip,
-  ae as inline,
-  re as offset,
+  lt as flip,
+  at as inline,
+  rt as offset,
   $ as rectToClientRect,
-  fe as shift
+  ft as shift
 };
 //# sourceMappingURL=annotorious-react.es22.js.map