@annotorious/react 3.7.22 → 3.8.1

package/dist/annotorious-react.es24.js

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